From 8ff1e52a69534ddffce98caa5bad7889c68cc84f Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:47:10 -0700 Subject: [PATCH 01/72] feat(viscy-utils): add the segmentation-aware and background losses Port the Spotlight-motivated losses from dynacell-models so they live in the shared package before any application consumes them: SegAuxDice (seg_aux.py) with the SAUNA-map and soft-clDice weight maps (seg_aux_maps.py), the segmenter-consistency loss (seg_consistency.py), the Track H background low-pass target (background_lowpass.py), and SpotlightLoss(return_components=True). Defaults keep SpotlightLoss's existing behavior; no package imports an application. Source on dynacell-models: 40de7939 (#498), 6c28a318 (#521), 0cbeda1b (#524), 050f553c (#530). Co-Authored-By: Claude Opus 5.5 --- .../src/viscy_utils/losses/__init__.py | 5 +- .../viscy_utils/losses/background_lowpass.py | 258 ++++++++ .../src/viscy_utils/losses/seg_aux.py | 310 +++++++++ .../src/viscy_utils/losses/seg_aux_maps.py | 363 ++++++++++ .../src/viscy_utils/losses/seg_consistency.py | 230 +++++++ .../src/viscy_utils/losses/spotlight.py | 24 +- .../tests/test_background_lowpass.py | 254 +++++++ .../viscy-utils/tests/test_seg_aux_loss.py | 619 ++++++++++++++++++ .../tests/test_seg_consistency_loss.py | 171 +++++ .../viscy-utils/tests/test_spotlight_loss.py | 34 + 10 files changed, 2263 insertions(+), 5 deletions(-) create mode 100644 packages/viscy-utils/src/viscy_utils/losses/background_lowpass.py create mode 100644 packages/viscy-utils/src/viscy_utils/losses/seg_aux.py create mode 100644 packages/viscy-utils/src/viscy_utils/losses/seg_aux_maps.py create mode 100644 packages/viscy-utils/src/viscy_utils/losses/seg_consistency.py create mode 100644 packages/viscy-utils/tests/test_background_lowpass.py create mode 100644 packages/viscy-utils/tests/test_seg_aux_loss.py create mode 100644 packages/viscy-utils/tests/test_seg_consistency_loss.py diff --git a/packages/viscy-utils/src/viscy_utils/losses/__init__.py b/packages/viscy-utils/src/viscy_utils/losses/__init__.py index 7bf90b536..9b6b89c25 100644 --- a/packages/viscy-utils/src/viscy_utils/losses/__init__.py +++ b/packages/viscy-utils/src/viscy_utils/losses/__init__.py @@ -1,4 +1,7 @@ +from viscy_utils.losses.background_lowpass import BackgroundLowPass from viscy_utils.losses.mixed_loss import MixedLoss +from viscy_utils.losses.seg_aux import SegAuxDice +from viscy_utils.losses.seg_consistency import SegConsistencyLoss from viscy_utils.losses.spotlight import SpotlightLoss -__all__ = ["MixedLoss", "SpotlightLoss"] +__all__ = ["BackgroundLowPass", "MixedLoss", "SegAuxDice", "SegConsistencyLoss", "SpotlightLoss"] diff --git a/packages/viscy-utils/src/viscy_utils/losses/background_lowpass.py b/packages/viscy-utils/src/viscy_utils/losses/background_lowpass.py new file mode 100644 index 000000000..7dbd40ed4 --- /dev/null +++ b/packages/viscy-utils/src/viscy_utils/losses/background_lowpass.py @@ -0,0 +1,258 @@ +"""Background low-pass of a training target, foreground interior kept unchanged. + +``x' = w * x + (1 - w) * B`` with ``m = dilate(fg_mask, r)``, +``w = clamp(G_f(m), 0, 1)`` and the background estimate +``B = G_lp(x * (1 - m)) / G_lp(1 - m)``: where the feather kernel lies inside +``m`` the target is unchanged, where it misses ``m`` the target is a Gaussian +low-pass of the background pixels alone, and in between the feather blends the +two without a seam. The blend reaches the feather radius inside ``m``, so a +feather radius above ``r`` also mixes a little ``B`` into the rim of the +foreground itself. + +``B`` is a normalized convolution: a plain ``G_lp(x)`` would bleed bright +foreground into the background as a halo, while ``B`` averages background +pixels only, so a foreground blob never reaches it. With ``sigma_lp=None`` (its +``sigma_lp -> inf`` limit) ``B`` is flat: the mean of each plane's background +pixels, which also removes autofluorescence and uneven illumination. + +It changes the target, never the loss: the background stays supervised toward a +smooth field. In flow matching, masking the background out of the loss would +leave the initial Gaussian noise there unremoved (the Spotlight v1 collapse). + +The Gaussians are normalized, edge-replicated (``scipy.ndimage`` ``mode="nearest"``, +``truncate=4.0``) and separable, applied as shifted multiply-adds in float32, so +no convolution backend (cuDNN TF32, autocast) can lower their precision. ``B`` is a +weighted mean of background pixels, so it keeps the local background level and +the op needs no change to the target's normalization. +""" + +import math + +import torch +import torch.nn.functional as F +from torch import Tensor, nn + +__all__ = ["BackgroundLowPass"] + +# At or below this fraction of the low-pass kernel's mass on background pixels the +# normalized convolution has no background in reach; B falls back to the plane's flat mean. +_MIN_BACKGROUND_WEIGHT = 1e-6 + + +def _gaussian_kernel(sigma: float, device: torch.device) -> Tensor: + """Return a normalized float32 1D Gaussian of radius ``int(4 * sigma + 0.5)``, as scipy does.""" + radius = int(4.0 * sigma + 0.5) + x = torch.arange(-radius, radius + 1, device=device, dtype=torch.float32) + k = torch.exp(-0.5 * (x / sigma) ** 2) + return k / k.sum() + + +def _gaussian_blur(x: Tensor, sigmas: tuple[float, float, float]) -> Tensor: + """Separable Gaussian blur of ``(N, D, H, W)`` with edge-replicated borders. + + Parameters + ---------- + x : Tensor + Float32, shape ``(N, D, H, W)``. + sigmas : tuple of float + Standard deviation in voxels along ``(D, H, W)``; 0 leaves that axis alone. + + Returns + ------- + Tensor + Blurred tensor, shape of ``x``. + """ + for dim, sigma in zip((1, 2, 3), sigmas): + length = x.shape[dim] + # A size-1 axis replicates its one value, so the blur along it is the identity. + if sigma <= 0 or length == 1: + continue + k = _gaussian_kernel(sigma, x.device) + r = k.numel() // 2 + # F.pad lists the last dim first; replicate supports any pad width. + pad = [0] * 6 + pad[2 * (3 - dim)] = pad[2 * (3 - dim) + 1] = r + padded = F.pad(x.unsqueeze(1), pad, mode="replicate").squeeze(1) + out = k[0] * padded.narrow(dim, 0, length) + for i in range(1, k.numel()): + out = out + k[i] * padded.narrow(dim, i, length) + x = out + return x + + +class BackgroundLowPass(nn.Module): + """Replace a target's background by a low-pass estimate from background pixels. + + ``x' = w * x + (1 - w) * B``, ``m = dilate(fg_mask > 0.5, r)``, + ``w = clamp(G_f(m), 0, 1)``, ``B = G_lp(x * (1 - m)) / G_lp(1 - m)``. + ``w`` is exactly 1 where the feather kernel lies entirely inside ``m`` (the + dilated mask shrunk by its radius, ``int(4 * sigma_feather + 0.5)``), so + ``x' = x`` exactly there, and exactly 0 where the kernel misses ``m``, so + ``x' = B`` exactly there. + + ``sigma_lp=None`` makes ``B`` flat: per sample, channel and Z plane, the mean + of ``x`` over the plane's background pixels, the ``sigma_lp -> inf`` limit of + the normalized convolution. Where the normalized convolution has at most + ``1e-6`` of its kernel mass on background (a thin background ring narrower + than its support, say), ``B`` falls back to that flat mean. A plane with no + background pixel at all has no estimate: ``B = x`` there, and with the + per-plane feather ``w == 1``, so the plane is returned unchanged. + + By default every operation acts in XY, per Z plane: Z is anisotropic, and + 2D models have ``D = 1``. The ``*_z`` parameters extend each to Z. + + Computed in float32 regardless of autocast; returned in the target's dtype. + + Parameters + ---------- + sigma_lp : float or None + Gaussian sigma in XY, in voxels, of the background estimate (> 0); + ``None`` (or ``inf``) for a flat background. + sigma_feather : float + Gaussian sigma in XY, in voxels, that feathers the dilated mask into + ``w`` (>= 0; 0 keeps the hard dilated mask). + dilate_radius : int + Dilation radius in XY, in voxels (>= 0): a ``(2r + 1)``-wide square. + sigma_lp_z : float + Background-estimate sigma along Z, in voxels (>= 0; 0 = per plane). + Must be 0 with a flat background, which is per plane. + sigma_feather_z : float + Feather sigma along Z, in voxels (>= 0; 0 = per plane). + dilate_radius_z : int + Dilation radius along Z, in voxels (>= 0; 0 = per plane). + """ + + def __init__( + self, + sigma_lp: float | None, + sigma_feather: float, + dilate_radius: int, + sigma_lp_z: float = 0.0, + sigma_feather_z: float = 0.0, + dilate_radius_z: int = 0, + ) -> None: + super().__init__() + if sigma_lp is not None and math.isinf(sigma_lp): + sigma_lp = None + if sigma_lp is None: + if sigma_lp_z != 0: + raise ValueError(f"sigma_lp_z={sigma_lp_z} has no effect with a flat background (sigma_lp=None)") + elif sigma_lp <= 0: + raise ValueError(f"sigma_lp must be > 0 or None, got {sigma_lp}") + for name, value in ( + ("sigma_feather", sigma_feather), + ("sigma_lp_z", sigma_lp_z), + ("sigma_feather_z", sigma_feather_z), + ("dilate_radius", dilate_radius), + ("dilate_radius_z", dilate_radius_z), + ): + if value < 0: + raise ValueError(f"{name} must be >= 0, got {value}") + self.sigma_lp = None if sigma_lp is None else float(sigma_lp) + self.sigma_feather = float(sigma_feather) + self.dilate_radius = int(dilate_radius) + self.sigma_lp_z = float(sigma_lp_z) + self.sigma_feather_z = float(sigma_feather_z) + self.dilate_radius_z = int(dilate_radius_z) + + def dilated_mask(self, fg_mask: Tensor) -> Tensor: + """Return ``m = dilate(fg_mask > 0.5, r)`` as float32 in {0, 1}. + + Parameters + ---------- + fg_mask : Tensor + Foreground mask, shape ``(B, C, D, H, W)``; binarized at 0.5. + + Returns + ------- + Tensor + Float32, shape of ``fg_mask``. + """ + b, c = fg_mask.shape[:2] + rz, r = self.dilate_radius_z, self.dilate_radius + mask = (fg_mask > 0.5).float().reshape(b * c, 1, *fg_mask.shape[2:]) + if rz or r: + # max_pool pads with -inf, so the border never dilates the mask. + mask = F.max_pool3d(mask, (2 * rz + 1, 2 * r + 1, 2 * r + 1), stride=1, padding=(rz, r, r)) + return mask.reshape(fg_mask.shape) + + def blend_weight(self, dilated: Tensor) -> Tensor: + """Return ``w = clamp(G_f(m), 0, 1)`` in float32, exactly 1 under an all-``m`` kernel. + + Parameters + ---------- + dilated : Tensor + Dilated mask ``m`` from :meth:`dilated_mask`, shape ``(B, C, D, H, W)``. + + Returns + ------- + Tensor + Float32 weights in [0, 1], shape of ``dilated``. + """ + b, c = dilated.shape[:2] + spatial = dilated.shape[2:] + with torch.autocast(device_type=dilated.device.type, enabled=False): + sigmas = (self.sigma_feather_z, self.sigma_feather, self.sigma_feather) + blurred = _gaussian_blur(dilated.float().reshape(b * c, *spatial), sigmas) + # The normalized kernel sums to 1 only up to rounding (0.99999982 at sigma 0.5). + # Edge replication makes the blur of ones the same value at every voxel, computed + # by the same operations as any all-ones window of m: dividing by it gives exactly + # 1 there. Size-2 axes reproduce it (size 1 is skipped, like in the full tensor). + ones = torch.ones((1, *(min(n, 2) for n in spatial)), device=dilated.device) + unit = _gaussian_blur(ones, sigmas)[0, 0, 0, 0] + return (blurred / unit).clamp(0.0, 1.0).reshape(dilated.shape) + + def background(self, target: Tensor, dilated: Tensor) -> Tensor: + """Return the background estimate ``B`` in float32; ``target`` on planes without background. + + Parameters + ---------- + target : Tensor + Target, shape ``(B, C, D, H, W)``. + dilated : Tensor + Dilated mask ``m`` from :meth:`dilated_mask`, same shape. + + Returns + ------- + Tensor + Float32, shape of ``target``. + """ + b, c = target.shape[:2] + spatial = target.shape[2:] + with torch.autocast(device_type=target.device.type, enabled=False): + x = target.float() + bg = 1.0 - dilated.float() + count = bg.sum(dim=(-2, -1), keepdim=True) + plane_mean = (x * bg).sum(dim=(-2, -1), keepdim=True) / count.clamp(min=1.0) + flat = torch.where(count > 0, plane_mean, x) + if self.sigma_lp is None: + return flat + sigmas = (self.sigma_lp_z, self.sigma_lp, self.sigma_lp) + num = _gaussian_blur((x * bg).reshape(b * c, *spatial), sigmas).reshape(x.shape) + den = _gaussian_blur(bg.reshape(b * c, *spatial), sigmas).reshape(x.shape) + defined = den > _MIN_BACKGROUND_WEIGHT + return torch.where(defined, num / den.clamp(min=_MIN_BACKGROUND_WEIGHT), flat) + + def forward(self, target: Tensor, fg_mask: Tensor) -> Tensor: + """Return the target with its background replaced by ``B``. + + Parameters + ---------- + target : Tensor + Target, shape ``(B, C, D, H, W)``. + fg_mask : Tensor + Foreground mask, same shape; binarized at 0.5. + + Returns + ------- + Tensor + ``w * target + (1 - w) * B``, shape and dtype of ``target``. + """ + if target.ndim != 5: + raise ValueError(f"target must be (B, C, D, H, W), got shape {tuple(target.shape)}") + if fg_mask.shape != target.shape: + raise ValueError(f"fg_mask {tuple(fg_mask.shape)} must match target {tuple(target.shape)}") + dilated = self.dilated_mask(fg_mask) + w = self.blend_weight(dilated) + x = target.float() + return (w * x + (1.0 - w) * self.background(target, dilated)).to(target.dtype) diff --git a/packages/viscy-utils/src/viscy_utils/losses/seg_aux.py b/packages/viscy-utils/src/viscy_utils/losses/seg_aux.py new file mode 100644 index 000000000..350e66664 --- /dev/null +++ b/packages/viscy-utils/src/viscy_utils/losses/seg_aux.py @@ -0,0 +1,310 @@ +"""Self-calibrating soft-Dice auxiliary loss for virtual staining. + +The prediction is soft-thresholded at a level derived per patch from the target +and the foreground mask it is scored against, so the loss needs no knowledge of +the normalization applied upstream (z-score, median/IQR, MinMax to [-1, 1]). + +For every (sample, channel) patch: + +- ``tau = quantile(target, 1 - mean(fg_mask))``: the level at which the target's + own foreground fraction equals the mask's. +- ``s = c * (median(target | fg) - median(target | bg))``: the knee width + relative to the patch's own foreground/background contrast. +- ``p = sigmoid((pred - tau) / s)``: bounded, with non-zero gradient everywhere. +- ``dice = 1 - 2 * sum(p * r) / (sum(p**2) + sum(r**2) + eps)``, where the + reference ``r`` is the binary mask (``label="mask"``) or the target through + the same sigmoid, ``sigmoid((target - tau) / s)`` (``label="target"``). + +``tau``, ``s`` and ``r`` are computed from the target without gradient. + +With ``label="mask"`` the loss is not zero at ``pred == target`` wherever the +mask is not a threshold of the target (0.07-0.25 on the iPSC baselines' +validation patches, 2026-09-24), so it also pulls the prediction toward the +mask. ``label="target"`` keeps the mask's role in setting ``tau``, ``s`` and +patch validity but is minimised exactly at ``pred == target``: it isolates a +segmentation-shaped penalty from that pull. + +Two optional, orthogonal extensions (both off by default, which leaves the loss +bit-identical to the plain soft Dice above): + +- ``weighting="sauna"`` weights every voxel's terms in both Dice sums by + ``|y~|``, the magnitude of SAUNA's combined boundary/thickness uncertainty map + of the patch's mask (:func:`~viscy_utils.losses.seg_aux_maps.sauna_weight_map`), + which down-weights the boundary of thick structures and keeps thin ones and + deep interiors/backgrounds at full weight. This is a SAUNA-map-weighted + binary soft Dice adapted from SAUNA's map, not SAUNA's loss: published SAUNA + (Oulu-IMEDS/SAUNA, ``SoftJaccardLoss``) regresses a tanh head toward the + signed ``y~`` with separate foreground (``relu(y~)``) and background + (``relu(-y~)``) soft-Jaccard terms. +- ``topology="cldice"`` replaces the per-patch loss by + ``(1 - alpha) * dice + alpha * (1 - clDice)`` with the soft-skeleton clDice. +""" + +import torch +from torch import Tensor, nn + +from viscy_utils.losses.seg_aux_maps import sauna_weight_map, soft_skeleton + +__all__ = ["SegAuxDice"] + + +def _quantile_sorted(sorted_rows: Tensor, q: Tensor) -> Tensor: + """Linearly interpolated per-row quantile of pre-sorted rows. + + Matches ``torch.quantile(..., interpolation="linear")`` but takes one + quantile level per row and has no input-size limit, which + ``torch.quantile`` imposes (2**24 elements) and large 3D patches exceed. + + Parameters + ---------- + sorted_rows : Tensor + Rows sorted ascending along the last dim, shape ``(R, N)``. + q : Tensor + Quantile level per row in ``[0, 1]``, shape ``(R,)``. + + Returns + ------- + Tensor + Quantile per row, shape ``(R,)``. + """ + n = sorted_rows.shape[-1] + pos = q.clamp(0.0, 1.0) * (n - 1) + lo = pos.floor().long() + hi = (lo + 1).clamp(max=n - 1) + frac = pos - lo.to(pos.dtype) + v_lo = sorted_rows.gather(-1, lo.unsqueeze(-1)).squeeze(-1) + v_hi = sorted_rows.gather(-1, hi.unsqueeze(-1)).squeeze(-1) + return v_lo + frac * (v_hi - v_lo) + + +def _masked_median(values: Tensor, keep: Tensor) -> Tensor: + """Linearly interpolated per-row median over the entries where ``keep`` is set. + + Parameters + ---------- + values : Tensor + Values, shape ``(R, N)``. + keep : Tensor + Boolean selection, shape ``(R, N)``. + + Returns + ------- + Tensor + Median per row, shape ``(R,)``; meaningless for rows with no kept entry. + """ + k = keep.sum(-1) + # Dropped entries sort to the end, so the first k sorted values are the kept ones. + sorted_rows = torch.where(keep, values, torch.full_like(values, float("inf"))).sort(dim=-1).values + pos = 0.5 * (k - 1).clamp(min=0).to(values.dtype) + lo = pos.floor().long() + hi = torch.minimum(lo + 1, (k - 1).clamp(min=0)) + frac = pos - lo.to(pos.dtype) + v_lo = sorted_rows.gather(-1, lo.unsqueeze(-1)).squeeze(-1) + v_hi = sorted_rows.gather(-1, hi.unsqueeze(-1)).squeeze(-1) + return v_lo + frac * (v_hi - v_lo) + + +class SegAuxDice(nn.Module): + """Squared-denominator soft Dice on a self-calibrated sigmoid of the prediction. + + Patches whose mask is empty or full, or whose target is not brighter inside + the mask than outside it (no contrast to set a knee width from), carry no + segmentation signal and are excluded from the mean. + + The knee width is set from the foreground/background contrast rather than + the patch IQR: on thin-structure patches (membrane) the IQR is ~0.65x the + contrast, which left 11-25% of foreground voxels with a vanishing sigmoid + gradient, against 0.5-7.5% with the contrast knee (measured on the iPSC + baselines' validation patches, 2026-09-24). If every patch is excluded the loss is a zero + that stays connected to ``pred``'s graph. + + Computed in float32 regardless of autocast. + + Parameters + ---------- + c : float + Knee width as a fraction of the patch's foreground/background contrast. + eps : float + Dice denominator stabilizer, and the floor on the knee width. + label : {"mask", "target"} + Dice reference: the binary foreground mask, or the target soft-thresholded + like the prediction (self-consistent; zero loss at ``pred == target``). + weighting : {"none", "sauna"} + ``"sauna"`` computes ``sum(w * p * r) / (sum(w * p**2) + sum(w * r**2))`` + with ``w = |y~|`` from the binarized mask, without gradient. + spacing : tuple of float or None + Physical voxel size per spatial dim, e.g. ``(z, y, x)`` in um; required + with ``weighting="sauna"`` (and only then), one entry per spatial dim. + topology : {"none", "cldice"} + ``"cldice"`` mixes in ``1 - clDice`` with weight ``cldice_alpha``. + cldice_alpha : float + Weight of ``1 - clDice`` in [0, 1]; the Dice term gets ``1 - cldice_alpha``. + cldice_iters : int + Soft-skeleton erosion iterations (>= 1). + """ + + def __init__( + self, + c: float = 0.1, + eps: float = 1e-6, + label: str = "mask", + weighting: str = "none", + spacing: tuple[float, ...] | None = None, + topology: str = "none", + cldice_alpha: float = 0.5, + cldice_iters: int = 10, + ) -> None: + super().__init__() + if c <= 0: + raise ValueError(f"c must be > 0, got {c}") + if eps <= 0: + raise ValueError(f"eps must be > 0, got {eps}") + if label not in ("mask", "target"): + raise ValueError(f"label must be 'mask' or 'target', got {label!r}") + if weighting not in ("none", "sauna"): + raise ValueError(f"weighting must be 'none' or 'sauna', got {weighting!r}") + if weighting == "sauna": + if spacing is None: + raise ValueError("weighting='sauna' needs spacing (physical voxel size per spatial dim)") + if len(spacing) == 0 or any(s <= 0 for s in spacing): + raise ValueError(f"spacing must be non-empty and positive, got {spacing}") + elif spacing is not None: + raise ValueError(f"spacing={spacing} has no effect without weighting='sauna'") + if topology not in ("none", "cldice"): + raise ValueError(f"topology must be 'none' or 'cldice', got {topology!r}") + if not 0.0 <= cldice_alpha <= 1.0: + raise ValueError(f"cldice_alpha must be in [0, 1], got {cldice_alpha}") + if cldice_iters < 1: + raise ValueError(f"cldice_iters must be >= 1, got {cldice_iters}") + self.c = c + self.eps = eps + self.label = label + self.weighting = weighting + self.spacing = None if spacing is None else tuple(float(s) for s in spacing) + self.topology = topology + self.cldice_alpha = cldice_alpha + self.cldice_iters = cldice_iters + + def per_channel(self, pred: Tensor, target: Tensor, fg_mask: Tensor) -> tuple[Tensor, Tensor]: + """Compute the Dice loss per (sample, channel) and which entries are valid. + + Parameters + ---------- + pred : Tensor + Prediction, shape ``(B, C, *spatial)``. + target : Tensor + Ground truth, same shape. + fg_mask : Tensor + Foreground mask, same shape; binarized at 0.5. + + Returns + ------- + tuple of (Tensor, Tensor) + Dice loss ``(B, C)`` in float32 (entries for invalid patches are + finite but meaningless) and the boolean validity mask ``(B, C)``. + """ + if pred.shape != target.shape or fg_mask.shape != target.shape: + raise ValueError( + f"pred, target and fg_mask must share a shape; got " + f"{tuple(pred.shape)}, {tuple(target.shape)}, {tuple(fg_mask.shape)}" + ) + b, c = target.shape[:2] + spatial = tuple(target.shape[2:]) + if self.spacing is not None and len(self.spacing) != len(spatial): + raise ValueError(f"spacing {self.spacing} has {len(self.spacing)} entries for {len(spatial)} spatial dims") + with torch.autocast(device_type=pred.device.type, enabled=False): + pred_f = pred.float().reshape(b * c, -1) + mask = (fg_mask.reshape(b * c, -1) > 0.5).float() + n = mask.shape[-1] + fg_count = mask.sum(-1) + with torch.no_grad(): + sorted_t = target.detach().float().reshape(b * c, -1).sort(dim=-1).values + q = 1.0 - fg_count / n + tau = _quantile_sorted(sorted_t, q) + flat_t = target.detach().float().reshape(b * c, -1) + fg = mask > 0.5 + contrast = _masked_median(flat_t, fg) - _masked_median(flat_t, ~fg) + valid = (fg_count > 0) & (fg_count < n) & (contrast > 0) + # An empty or full mask makes one median inf; substitute a finite + # width so invalid entries stay finite and the mask-multiply in + # forward() can zero them (inf * 0 would be NaN). + s = torch.where(valid, self.c * contrast, torch.ones_like(contrast)).clamp(min=self.eps) + if self.label == "target": + ref = torch.sigmoid((flat_t - tau.unsqueeze(-1)) / s.unsqueeze(-1)) + else: + ref = mask + p = torch.sigmoid((pred_f - tau.unsqueeze(-1)) / s.unsqueeze(-1)) + if self.weighting == "sauna": + with torch.no_grad(): + w = sauna_weight_map(fg.reshape(b * c, *spatial), self.spacing).reshape(b * c, -1) + inter = (w * p * ref).sum(-1) + denom = (w * p * p).sum(-1) + (w * ref * ref).sum(-1) + self.eps + else: + inter = (p * ref).sum(-1) + denom = (p * p).sum(-1) + (ref * ref).sum(-1) + self.eps + dice = 1.0 - 2.0 * inter / denom + if self.topology == "cldice": + dice = (1.0 - self.cldice_alpha) * dice + self.cldice_alpha * ( + 1.0 - self._cldice(p, ref, (b * c, 1, *spatial)) + ) + return dice.reshape(b, c), valid.reshape(b, c) + + def _cldice(self, p: Tensor, ref: Tensor, shape: tuple[int, ...]) -> Tensor: + """Soft clDice per row; gradient flows through ``p`` and its skeleton only. + + Parameters + ---------- + p : Tensor + Soft prediction, shape ``(R, N)``. + ref : Tensor + Reference, shape ``(R, N)``. + shape : tuple of int + ``(R, 1, *spatial)`` to restore the spatial layout. + + Returns + ------- + Tensor + clDice per row, shape ``(R,)``. + """ + skel_p = soft_skeleton(p.reshape(shape), self.cldice_iters).reshape(p.shape) + with torch.no_grad(): + skel_r = soft_skeleton(ref.reshape(shape), self.cldice_iters).reshape(ref.shape) + # eps on both sides (clDice's "smooth"): an empty skeleton reads as perfect, not 0/0. + t_prec = ((skel_p * ref).sum(-1) + self.eps) / (skel_p.sum(-1) + self.eps) + t_sens = ((skel_r * p).sum(-1) + self.eps) / (skel_r.sum(-1) + self.eps) + return 2.0 * t_prec * t_sens / (t_prec + t_sens + self.eps) + + def forward( + self, + pred: Tensor, + target: Tensor, + fg_mask: Tensor, + return_components: bool = False, + ) -> Tensor | tuple[Tensor, dict[str, Tensor]]: + """Compute the mean Dice loss over valid (sample, channel) patches. + + Parameters + ---------- + pred : Tensor + Prediction, shape ``(B, C, *spatial)``. + target : Tensor + Ground truth, same shape. + fg_mask : Tensor + Foreground mask, same shape; binarized at 0.5. + return_components : bool + When ``True``, also return ``{"dice": loss, "n_valid": count}``. + + Returns + ------- + Tensor or tuple of (Tensor, dict of str to Tensor) + Scalar float32 loss, optionally with its components. + """ + dice, valid = self.per_channel(pred, target, fg_mask) + n_valid = valid.sum() + # Invalid entries are finite, so multiplying by the mask zeroes them while + # keeping the graph: with no valid patch this is a connected 0 / 1, and no + # host sync is needed to branch on n_valid. + loss = (dice * valid).sum() / n_valid.clamp(min=1) + if return_components: + return loss, {"dice": loss, "n_valid": n_valid.float()} + return loss diff --git a/packages/viscy-utils/src/viscy_utils/losses/seg_aux_maps.py b/packages/viscy-utils/src/viscy_utils/losses/seg_aux_maps.py new file mode 100644 index 000000000..f2bebb88c --- /dev/null +++ b/packages/viscy-utils/src/viscy_utils/losses/seg_aux_maps.py @@ -0,0 +1,363 @@ +"""Mask-derived maps for :class:`~viscy_utils.losses.SegAuxDice`. + +- :func:`squared_edt`: exact, separable, anisotropic squared Euclidean distance + transform in torch (no cupy/cucim needed), on CPU or GPU. +- :func:`sauna_weight_map`: the SAUNA combined boundary/thickness uncertainty + map ("h" variant) of a binary mask, as a per-voxel Dice weight. +- :func:`soft_skeleton`: the clDice soft skeleton. + +SAUNA: Oulu-IMEDS/SAUNA, ``mlpipeline/utils/generate_uncertainty_masks.py`` +(``extract_boundary_uncertainty_map``, ``extract_thickness_uncertainty_map`` +with ``target_c_label="h"``, ``extract_combined_uncertainty_map``). +clDice: jocpae/clDice, ``soft_skeleton.py``. +""" + +import math +from collections.abc import Sequence + +import torch +import torch.nn.functional as F +from torch import Tensor +from torch.utils.checkpoint import checkpoint + +__all__ = ["box_max", "sauna_weight_map", "soft_skeleton", "squared_edt"] + +# Elements in one (lines, L, L) block of the brute-force EDT pass: 2**26 float32 = 256 MiB. +_EDT_BLOCK_ELEMENTS = 2**26 + + +def _nearest_seed_1d_squared(seeds: Tensor, spacing: float, dim: int) -> Tensor: + """Squared distance to the nearest seed along ``dim``, by two scans. + + Parameters + ---------- + seeds : Tensor + Boolean, any shape. + spacing : float + Physical size of one step along ``dim``. + dim : int + Axis to scan. + + Returns + ------- + Tensor + Float32 squared distance, shape of ``seeds``; ``inf`` on lines with no seed. + """ + shape = [1] * seeds.ndim + shape[dim] = seeds.shape[dim] + idx = torch.arange(seeds.shape[dim], device=seeds.device, dtype=torch.float32).reshape(shape) + left = torch.where(seeds, idx, float("-inf")).cummax(dim=dim).values + right = torch.where(seeds, idx, float("inf")).flip(dim).cummin(dim=dim).values.flip(dim) + dist = torch.minimum(idx - left, right - idx) * spacing + return dist * dist + + +def _lower_envelope_1d(f: Tensor, spacing: float, band: int | None) -> Tensor: + """``out[x] = min_y f[y] + (spacing * (x - y))**2`` along the last dim, brute force. + + Parameters + ---------- + f : Tensor + Float32, shape ``(M, L)``; may hold ``inf``. + spacing : float + Physical size of one step along the last dim. + band : int or None + Only consider ``|x - y| <= band``; ``None`` searches the whole line. + + Returns + ------- + Tensor + Shape ``(M, L)``. + """ + m, length = f.shape + out = torch.empty_like(f) + if band is None or 2 * band + 1 >= length: + pos = torch.arange(length, device=f.device, dtype=torch.float32) * spacing + offsets = (pos[:, None] - pos[None, :]) ** 2 # (x, y) + rows = max(1, _EDT_BLOCK_ELEMENTS // (length * length)) + for start in range(0, m, rows): + out[start : start + rows] = (f[start : start + rows, None, :] + offsets).amin(dim=-1) + return out + steps = torch.arange(-band, band + 1, device=f.device, dtype=torch.float32) * spacing + offsets = steps * steps # (2 * band + 1,) + rows = max(1, _EDT_BLOCK_ELEMENTS // (length * (2 * band + 1))) + for start in range(0, m, rows): + padded = F.pad(f[start : start + rows], (band, band), value=float("inf")) + out[start : start + rows] = (padded.unfold(-1, 2 * band + 1, 1) + offsets).amin(dim=-1) + return out + + +def _along_axis(x: Tensor, axis: int, fn) -> Tensor: + """Apply a ``(M, L) -> (M, L)`` function along ``axis`` of ``x``.""" + moved = x.movedim(axis, -1) + shape = moved.shape + return fn(moved.reshape(-1, shape[-1])).reshape(shape).movedim(-1, axis) + + +def squared_edt(seeds: Tensor, spacing: Sequence[float], max_distance: float | None = None) -> Tensor: + """Exact squared Euclidean distance from every voxel to the nearest seed. + + Separable (Saito-Toriwaki): an exact two-scan 1D pass along the largest + axis, then a brute-force lower-envelope pass along each other axis, blocked + to bound memory. Size-1 axes are skipped. Matches + ``scipy.ndimage.distance_transform_edt(~seeds, sampling=spacing) ** 2``. + + With ``max_distance`` the result is ``min(d**2, max_distance**2)``, still + exact: every value is capped at ``max_distance**2`` before each pass, so no + minimizer that matters lies further than ``max_distance`` along any line, + and each pass only searches that band. + + Parameters + ---------- + seeds : Tensor + Boolean, shape ``(N, *spatial)``; each of the ``N`` rows is independent. + spacing : Sequence[float] + Physical voxel size per spatial dim. + max_distance : float or None + Cap on the returned distance; ``None`` for none. + + Returns + ------- + Tensor + Float32 squared distances, shape of ``seeds``; 0 on seeds and, without + a cap, ``inf`` everywhere in a row without any seed. + """ + spatial = seeds.shape[1:] + if len(spacing) != len(spatial): + raise ValueError(f"spacing has {len(spacing)} entries for {len(spatial)} spatial dims") + cap2 = None if max_distance is None else float(max_distance) ** 2 + axes = [a for a in range(len(spatial)) if spatial[a] > 1] + first = max(axes, key=lambda a: spatial[a]) if axes else None + if first is None: + d2 = torch.where(seeds, 0.0, float("inf")).float() + else: + d2 = _nearest_seed_1d_squared(seeds, float(spacing[first]), first + 1) + if cap2 is not None: + d2 = d2.clamp(max=cap2) + for a in axes: + if a != first: + band = None if max_distance is None else math.ceil(max_distance / spacing[a]) + d2 = _along_axis(d2, a + 1, lambda f, a=a, band=band: _lower_envelope_1d(f, float(spacing[a]), band)) + # Passes keep values exact where the true distance is within the cap and >= the cap elsewhere. + return d2 if cap2 is None else d2.clamp(max=cap2) + + +def _axis_distance_bound(seeds: Tensor, spacing: Sequence[float]) -> Tensor: + """Per-voxel upper bound on the distance to the nearest seed. + + The smallest distance to a seed along any single axis: 1D scans only, cheap. + """ + bound2 = torch.full(seeds.shape, float("inf"), device=seeds.device) + for a in range(seeds.ndim - 1): + if seeds.shape[a + 1] > 1: + d2 = _nearest_seed_1d_squared(seeds, float(spacing[a]), a + 1) + bound2 = torch.minimum(bound2, d2) + return bound2.sqrt() + + +def _window_max(x: Tensor, k: int, dim: int) -> Tensor: + """Max over a centred odd window ``k`` along ``dim``, ``-inf`` beyond the edges. + + Doubling (sparse-table) maxima: ``log2(k)`` elementwise passes, no pooling + indices. Equal to ``max_pool1d(k, stride=1, padding=k // 2)`` along ``dim``. + """ + length = x.shape[dim] + pad = [0, 0] * (x.ndim - 1 - dim) + [k // 2, k // 2] + m = F.pad(x, pad, value=float("-inf")) # length + k - 1 along dim + span = 1 + while 2 * span <= k: + n = m.shape[dim] - span + m = torch.maximum(m.narrow(dim, 0, n), m.narrow(dim, span, n)) + span *= 2 + # m[j] = max over [j, j + span); combine two overlapping spans to cover k. + return torch.maximum(m.narrow(dim, 0, length), m.narrow(dim, k - span, length)) + + +def box_max(x: Tensor, windows: Sequence[int]) -> Tensor: + """Box max filter, stride 1, same size, as sequential 1D window maxima. + + Parameters + ---------- + x : Tensor + Float, shape ``(N, *spatial)``. + windows : Sequence[int] + Odd window length per spatial dim; 1 leaves that dim alone. + + Returns + ------- + Tensor + Filtered tensor, shape of ``x``. + """ + for a, k in enumerate(windows): + length = x.shape[a + 1] + # A window wider than 2L - 1 already covers the whole line from every voxel. + k = min(k, 2 * length - 1) + if k <= 1: + continue + x = _window_max(x, k, a + 1) + return x + + +def _odd_windows(radius: float, spacing: Sequence[float]) -> list[int]: + """SAUNA's ``do_max_pooling`` kernel per axis: ``ceil(radius)`` voxels, made odd.""" + windows = [] + for s in spacing: + k = math.ceil(radius / s) + windows.append(k + 1 if k % 2 == 0 else k) + return windows + + +def sauna_weight_map(mask: Tensor, spacing: Sequence[float]) -> Tensor: + """Per-voxel Dice weight ``|y~|`` from SAUNA's combined "h" uncertainty map. + + With ``fg_dist`` the distance of each voxel to the nearest background voxel + and ``bg_dist`` to the nearest foreground voxel (physical units), + ``fg_max = max(fg_dist)``: + + - boundary map ``gt_b = (fg_dist - min(bg_dist, fg_max)) / fg_max``; + - thickness map ``gt_t``: box max of ``fg_dist`` over a window of + ``fg_max`` per axis, over ``fg_max`` on foreground; box max of + ``min(bg_dist, fg_max)`` (window from that map's own maximum, as SAUNA + does) over ``fg_max``, clipped to [0, 1], on background; + - ``y~ = clip(gt_b + (1 - gt_t), -1, 1)`` on foreground and + ``clip(gt_b - (1 - gt_t), -1, 1)`` on background. + + Rows with no foreground or no background get weight 1. + + Using ``|y~|`` as a Dice weight is this package's adaptation of the map, + not part of SAUNA, which regresses a tanh head toward the signed ``y~`` + (see :func:`sauna_signed_map`). + + Parameters + ---------- + mask : Tensor + Boolean foreground, shape ``(N, *spatial)``. + spacing : Sequence[float] + Physical voxel size per spatial dim. + + Returns + ------- + Tensor + Float32 weights in [0, 1], shape of ``mask``. + """ + y = sauna_signed_map(mask, spacing) + ok = _has_fg_and_bg(mask) + return torch.where(_expand_rows(ok, mask), y.abs(), torch.ones_like(y)) + + +def _has_fg_and_bg(mask: Tensor) -> Tensor: + flat = mask.reshape(mask.shape[0], -1) + return flat.any(-1) & (~flat).any(-1) + + +def _expand_rows(row_values: Tensor, like: Tensor) -> Tensor: + return row_values.reshape(-1, *([1] * (like.ndim - 1))) + + +def sauna_signed_map(mask: Tensor, spacing: Sequence[float]) -> Tensor: + """SAUNA's signed combined map ``y~`` in [-1, 1] (see :func:`sauna_weight_map`). + + Parameters + ---------- + mask : Tensor + Boolean foreground, shape ``(N, *spatial)``. + spacing : Sequence[float] + Physical voxel size per spatial dim. + + Returns + ------- + Tensor + Float32, shape of ``mask``; 0 in rows with no foreground or no background. + """ + n = mask.shape[0] + ok_rows = _has_fg_and_bg(mask) + ok = _expand_rows(ok_rows, mask) + if not ok_rows.any(): + return torch.zeros(mask.shape, device=mask.device) + # Both EDTs only need to be exact up to the largest foreground distance: + # fg_dist never exceeds it and bg_dist is clipped to it. The fg cap is a + # cheap upper bound on fg_max, taken over rows that have background. + fg_bound = _axis_distance_bound(~mask, spacing).reshape(n, -1).amax(-1)[ok_rows].amax().item() + fg_cap = fg_bound if math.isfinite(fg_bound) else None + # Rows lacking fg or bg have inf / capped distances; zero them so everything stays finite. + fg_dist = torch.where(ok, squared_edt(~mask, spacing, max_distance=fg_cap).sqrt(), 0.0) + fg_max = fg_dist.reshape(n, -1).amax(-1) + fg_max = torch.where(fg_max > 0, fg_max, torch.ones_like(fg_max)) + bg_dist = torch.where(ok, squared_edt(mask, spacing, max_distance=fg_max.max().item()).sqrt(), 0.0) + bg_clip = torch.minimum(bg_dist, _expand_rows(fg_max, mask)) + bg_max = bg_clip.reshape(n, -1).amax(-1) + # Windows differ per row (each patch has its own fg_max): filter row by row. + fg_pool = torch.empty_like(fg_dist) + bg_pool = torch.empty_like(bg_clip) + for i, (fg_r, bg_r) in enumerate(zip(fg_max.tolist(), bg_max.tolist())): + fg_pool[i : i + 1] = box_max(fg_dist[i : i + 1], _odd_windows(fg_r, spacing)) + bg_pool[i : i + 1] = box_max(bg_clip[i : i + 1], _odd_windows(bg_r, spacing)) + fg_max_b = _expand_rows(fg_max, mask) + gt_b = (fg_dist - bg_clip) / fg_max_b + gt_t = torch.where(mask, fg_pool / fg_max_b, (bg_pool / fg_max_b).clamp(0.0, 1.0)) + y = torch.where(mask, gt_b + (1.0 - gt_t), gt_b - (1.0 - gt_t)).clamp(-1.0, 1.0) + return torch.where(ok, y, 0.0) + + +def _max_pool(x: Tensor, kernel: tuple[int, ...]) -> Tensor: + """Stride-1, same-size max-pool of ``(N, 1, *spatial)`` over 1-3 spatial dims.""" + pool = {1: F.max_pool1d, 2: F.max_pool2d, 3: F.max_pool3d}[len(kernel)] + return pool(x, kernel, stride=1, padding=tuple(k // 2 for k in kernel)) + + +def _soft_erode(x: Tensor) -> Tensor: + """ClDice ``soft_erode``: min of the 1D 3-voxel min-pools along each axis (the cross).""" + nd = x.ndim - 2 + out = None + for a in range(nd): + kernel = tuple(3 if i == a else 1 for i in range(nd)) + eroded = -_max_pool(-x, kernel) + out = eroded if out is None else torch.minimum(out, eroded) + return out + + +def _soft_dilate(x: Tensor) -> Tensor: + """ClDice ``soft_dilate``: 3^n box max-pool.""" + return _max_pool(x, (3,) * (x.ndim - 2)) + + +def _soft_open(x: Tensor) -> Tensor: + return _soft_dilate(_soft_erode(x)) + + +def _skeleton_step(img: Tensor, skel: Tensor) -> tuple[Tensor, Tensor]: + img = _soft_erode(img) + delta = F.relu(img - _soft_open(img)) + return img, skel + F.relu(delta - skel * delta) + + +def soft_skeleton(img: Tensor, iters: int) -> Tensor: + """ClDice soft skeleton (jocpae/clDice ``soft_skel``), in 1-3 spatial dims. + + When a gradient is needed every iteration is activation-checkpointed: each + one holds ~a dozen full-size intermediates (pool values and int64 indices), + which for a + ``(8, 1, 32, 384, 384)`` batch and 10 iterations exceeded a 48 GB GPU. + Checkpointing keeps two tensors per iteration and recomputes the rest in + backward; values and gradients are unchanged by it. + + Parameters + ---------- + img : Tensor + Soft mask in [0, 1], shape ``(N, 1, *spatial)``. + iters : int + Erosion iterations; should exceed the largest foreground radius in voxels. + + Returns + ------- + Tensor + Soft skeleton, shape of ``img``. + """ + checkpointed = img.requires_grad and torch.is_grad_enabled() + skel = F.relu(img - _soft_open(img)) + for _ in range(iters): + if checkpointed: + img, skel = checkpoint(_skeleton_step, img, skel, use_reentrant=False) + else: + img, skel = _skeleton_step(img, skel) + return skel diff --git a/packages/viscy-utils/src/viscy_utils/losses/seg_consistency.py b/packages/viscy-utils/src/viscy_utils/losses/seg_consistency.py new file mode 100644 index 000000000..58e658c10 --- /dev/null +++ b/packages/viscy-utils/src/viscy_utils/losses/seg_consistency.py @@ -0,0 +1,230 @@ +"""Segmenter-consistency loss for virtual staining (ControlNet++ style). + +A frozen, differentiable segmenter ``S`` is run on the prediction and on the target, +and their dense, pre-threshold outputs are matched: + +``L = mean_px ( mean_c (flow_pred - flow_target)**2 + KL(q_target || q_pred) )`` + +- ``flow`` are the segmenter's two flow channels and ``q = sigmoid(cellprob_logit)``. +- The probability term is the binary KL, i.e. BCE-with-logits against the target's + soft probability minus that probability's entropy: the gradient is BCE's, and the + loss is exactly 0 at ``pred == target``. The loss equals the G4 gate's + ``D_total = D_flow + D_prob``. +- ``S(target)`` is computed under ``no_grad`` on the same augmented crop, every step; + ``S(pred)`` carries the gradient into the prediction. ``S`` itself gets none. + +The segmenter sees 2-D images. A crop ``(B, 1, Z, Y, X)`` is reduced to the +``2 * slab_halfwidth + 1``-plane max projection around its nuclear-area focus plane: +the plane of largest Otsu foreground fraction of the target crop, with the outer 15% +of planes excluded and the crop center as the fallback, as +``dynacell.evaluation.focus.nucleus_area_plane`` picks the plane the eval segments +(slab halfwidth 1 there). The same planes are projected from the prediction. One +segmenter pass per sample is the cheapest geometry the G4 bench measured, and it is +the geometry the eval scores. ``Z = 1`` crops (2-D models) give their single plane. +The projection is then center-cropped to ``crop_size``: 240 px, which Cellpose pads to +exactly one 256-px tile (a 256-px crop pads to 272 and costs 2 x 2 tiles). + +The segmenter is held outside the module tree, so its weights never enter a +``state_dict`` (checkpoints stay the backbone's, and ``ckpt_path`` loads of baseline +checkpoints stay strict) and the module's ``train()`` cannot switch it out of eval +mode. It follows the prediction's device on first use. It runs with autocast +disabled, in its own dtype, as stock inference does. +""" + +import torch +import torch.nn.functional as F +from torch import Tensor, nn + +__all__ = ["SegConsistencyLoss", "nucleus_area_planes"] + +_GUARD_FRAC = 0.15 +_MIN_FOREGROUND = 0.01 +_OTSU_BINS = 256 + + +def _otsu_thresholds(flat: Tensor) -> Tensor: + """Per-row Otsu threshold, as ``skimage.filters.threshold_otsu`` (256 bins over each row's range). + + Parameters + ---------- + flat : Tensor + Values, shape ``(R, N)``. A constant row gets a meaningless threshold. + + Returns + ------- + Tensor + Threshold per row, shape ``(R,)``: the center of the bin maximizing the + between-class variance. + """ + lo = flat.amin(1, keepdim=True) + width = ((flat.amax(1, keepdim=True) - lo) / _OTSU_BINS).clamp_min(torch.finfo(flat.dtype).tiny) + idx = ((flat - lo) / width).floor().long().clamp(0, _OTSU_BINS - 1) + # scatter_add_ rather than bincount: bincount sizes its output on the host (a sync). + hist = torch.zeros(flat.shape[0], _OTSU_BINS, device=flat.device, dtype=torch.long) + hist = hist.scatter_add_(1, idx, torch.ones((), device=flat.device, dtype=torch.long).expand_as(idx)).double() + centers = lo.double() + width.double() * (torch.arange(_OTSU_BINS, device=flat.device) + 0.5) + w1 = hist.cumsum(1) + w2 = hist.flip(1).cumsum(1).flip(1) + m1 = (hist * centers).cumsum(1) / w1 + m2 = (hist * centers).flip(1).cumsum(1).flip(1) / w2 + var = w1[:, :-1] * w2[:, 1:] * (m1[:, :-1] - m2[:, 1:]) ** 2 + return centers.gather(1, var.argmax(1, keepdim=True)).squeeze(1).to(flat.dtype) + + +@torch.no_grad() +def nucleus_area_planes(vol: Tensor) -> Tensor: + """Return each volume's plane of largest nuclear foreground area, without a host sync. + + Mirrors ``dynacell.evaluation.focus.nucleus_area_plane``: Otsu over the whole + volume, per-plane foreground fraction, argmax inside a band that drops the outer + 15% of planes; a constant volume, or one whose band peak is below 1% foreground, + falls back to the center plane. + + Parameters + ---------- + vol : Tensor + Volumes, shape ``(B, Z, Y, X)``. + + Returns + ------- + Tensor + Plane index per volume, shape ``(B,)``, int64. + """ + b, z = vol.shape[:2] + center = torch.full((b,), z // 2, device=vol.device, dtype=torch.long) + flat = vol.reshape(b, -1).float() + # A constant row has no threshold; its NaN/arbitrary one is discarded below. + constant = flat.amax(1) <= flat.amin(1) + thr = _otsu_thresholds(flat) + frac = (flat > thr.unsqueeze(1)).reshape(b, z, -1).float().mean(2) + lo = int(round(_GUARD_FRAC * z)) + hi = max(lo + 1, int(round((1.0 - _GUARD_FRAC) * z))) + band = frac[:, lo:hi] + peak, arg = band.max(1) + use_center = constant | (peak < _MIN_FOREGROUND) + return torch.where(use_center, center, lo + arg) + + +def _slab_mip(vol: Tensor, planes: Tensor, halfwidth: int) -> Tensor: + """Max-project ``(B, Z, Y, X)`` onto the planes ``[p - h, p + h]`` clipped to the stack. + + Clipping repeats an edge plane, which leaves the maximum unchanged, so this equals + ``dynacell.evaluation.focus.slab_mip``. Returns ``(B, Y, X)``. + """ + z = vol.shape[1] + offsets = torch.arange(-halfwidth, halfwidth + 1, device=vol.device) + idx = (planes.unsqueeze(1) + offsets).clamp(0, z - 1) + idx = idx[:, :, None, None].expand(-1, -1, *vol.shape[2:]) + return vol.gather(1, idx).amax(1) + + +def _center_crop(img: Tensor, size: int | None) -> Tensor: + """Center-crop ``(..., Y, X)`` to at most ``size`` per side (no-op when ``None``).""" + if size is None: + return img + y, x = img.shape[-2:] + oy, ox = max(0, (y - size) // 2), max(0, (x - size) // 2) + return img[..., oy : oy + min(y, size), ox : ox + min(x, size)] + + +def _binary_kl(p_logit: Tensor, q_logit: Tensor) -> Tensor: + """Per-element binary KL(q || p) for ``q = sigmoid(q_logit)``; 0 iff the logits match.""" + q = torch.sigmoid(q_logit) + bce = F.binary_cross_entropy_with_logits(p_logit, q, reduction="none") + ent = F.binary_cross_entropy_with_logits(q_logit, q, reduction="none") + return bce - ent + + +class SegConsistencyLoss(nn.Module): + """Match a frozen segmenter's flows and cell probability on prediction and target. + + Parameters + ---------- + segmenter : nn.Module + Frozen differentiable segmenter mapping ``(N, 1, Y, X)`` images in any + positive-affine units to ``{"flow": (N, 2, Y, X), "cellprob_logit": (N, 1, Y, X)}`` + (e.g. ``dynacell.cellpose_dense.CellposeDense``). Put in eval mode with + ``requires_grad=False`` here; never the evaluation segmenter. + slab_halfwidth : int + Half-width of the max projection around a 3-D crop's focus plane. + crop_size : int or None + Center-crop side of the projected image, ``None`` for the whole image. + """ + + def __init__( + self, + segmenter: nn.Module, + slab_halfwidth: int = 1, + crop_size: int | None = 240, + ) -> None: + super().__init__() + if slab_halfwidth < 0: + raise ValueError(f"slab_halfwidth must be >= 0, got {slab_halfwidth}") + if crop_size is not None and crop_size < 1: + raise ValueError(f"crop_size must be >= 1 or None, got {crop_size}") + segmenter.eval() + segmenter.requires_grad_(False) + # Bypass nn.Module.__setattr__ so the segmenter is not a registered submodule. + self.__dict__["segmenter"] = segmenter + self.slab_halfwidth = slab_halfwidth + self.crop_size = crop_size + + def project(self, pred: Tensor, target: Tensor) -> tuple[Tensor, Tensor]: + """Reduce ``pred`` and ``target`` to the 2-D images the segmenter scores. + + Parameters + ---------- + pred, target : Tensor + Shape ``(B, 1, Z, Y, X)``. + + Returns + ------- + tuple of (Tensor, Tensor) + Projected ``pred`` and ``target``, each ``(B, 1, Y', X')``. + """ + if pred.shape != target.shape: + raise ValueError(f"pred and target must share a shape; got {tuple(pred.shape)}, {tuple(target.shape)}") + if pred.ndim != 5 or pred.shape[1] != 1: + raise ValueError(f"expected (B, 1, Z, Y, X), got {tuple(pred.shape)}") + planes = nucleus_area_planes(target[:, 0].detach()) + pred = _slab_mip(pred[:, 0], planes, self.slab_halfwidth).unsqueeze(1) + target = _slab_mip(target[:, 0], planes, self.slab_halfwidth).unsqueeze(1) + return _center_crop(pred, self.crop_size), _center_crop(target, self.crop_size) + + def _segment(self, img: Tensor) -> dict[str, Tensor]: + seg = self.segmenter + if next(seg.parameters()).device != img.device: + seg.to(img.device) + with torch.autocast(device_type=img.device.type, enabled=False): + return seg(img.to(torch.promote_types(img.dtype, torch.float32))) + + def forward( + self, pred: Tensor, target: Tensor, return_components: bool = False + ) -> Tensor | tuple[Tensor, dict[str, Tensor]]: + """Compute the consistency loss. + + Parameters + ---------- + pred : Tensor + Prediction, ``(B, 1, Z, Y, X)``. + target : Tensor + Ground truth, same shape. + return_components : bool + Also return ``{"segcons", "segcons_flow", "segcons_prob"}``. + + Returns + ------- + Tensor or tuple of (Tensor, dict of str to Tensor) + Scalar float32 loss, optionally with its flow and probability terms. + """ + pred2d, target2d = self.project(pred, target.detach()) + with torch.no_grad(): + ref = self._segment(target2d) + out = self._segment(pred2d) + flow_sq = ((out["flow"] - ref["flow"]) ** 2).mean(1) + kl = _binary_kl(out["cellprob_logit"], ref["cellprob_logit"])[:, 0] + flow_term, prob_term = flow_sq.mean(), kl.mean() + loss = flow_term + prob_term + if return_components: + return loss, {"segcons": loss, "segcons_flow": flow_term, "segcons_prob": prob_term} + return loss diff --git a/packages/viscy-utils/src/viscy_utils/losses/spotlight.py b/packages/viscy-utils/src/viscy_utils/losses/spotlight.py index 1d74a52a3..c059255b1 100644 --- a/packages/viscy-utils/src/viscy_utils/losses/spotlight.py +++ b/packages/viscy-utils/src/viscy_utils/losses/spotlight.py @@ -158,7 +158,13 @@ def __init__( self.fg_threshold = fg_threshold self._warned_no_real_mask = False - def forward(self, pred: Tensor, target: Tensor, fg_mask: Tensor | None = None) -> Tensor: + def forward( + self, + pred: Tensor, + target: Tensor, + fg_mask: Tensor | None = None, + return_components: bool = False, + ) -> Tensor | tuple[Tensor, dict[str, Tensor]]: """Compute the Spotlight loss. Loss is computed per (batch, channel) pair and averaged. Channels @@ -176,11 +182,18 @@ def forward(self, pred: Tensor, target: Tensor, fg_mask: Tensor | None = None) - When provided, used directly instead of computing from target. When None (default), mask is computed at runtime using ``fg_threshold`` or Otsu thresholding. + return_components : bool + When ``True``, also return the two terms that make up the loss. + The terms are the ones actually summed here, so logging them is a + faithful record of the objective being optimized — re-deriving them + in the caller would silently fork from it. Returns ------- - Tensor - Scalar loss value. + Tensor or tuple of (Tensor, dict of str to Tensor) + Scalar loss value, or ``(loss, {"masked_mse": ..., "dice": ...})`` + when ``return_components`` is ``True``. The components are the + unweighted terms, before ``lambda_mse`` is applied. """ # Foreground mask: precomputed > fixed threshold > per-(sample, channel) Otsu if fg_mask is not None: @@ -222,4 +235,7 @@ def forward(self, pred: Tensor, target: Tensor, fg_mask: Tensor | None = None) - self._warned_no_real_mask = True dice = pred.new_tensor(0.0) - return self.lambda_mse * masked_mse + (1 - self.lambda_mse) * dice + total = self.lambda_mse * masked_mse + (1 - self.lambda_mse) * dice + if return_components: + return total, {"masked_mse": masked_mse, "dice": dice} + return total diff --git a/packages/viscy-utils/tests/test_background_lowpass.py b/packages/viscy-utils/tests/test_background_lowpass.py new file mode 100644 index 000000000..d5012ffe5 --- /dev/null +++ b/packages/viscy-utils/tests/test_background_lowpass.py @@ -0,0 +1,254 @@ +"""Unit tests for BackgroundLowPass, checked against scipy.ndimage references.""" + +import numpy as np +import pytest +import torch +from scipy import ndimage + +from viscy_utils.losses import BackgroundLowPass + + +def _square_batch(shape: tuple[int, ...], lo: int, hi: int, seed: int = 0) -> tuple[torch.Tensor, torch.Tensor]: + """Noisy target with a bright square; mask = the square ``[lo, hi)`` in YX of every plane.""" + g = torch.Generator().manual_seed(seed) + mask = torch.zeros(shape) + mask[..., lo:hi, lo:hi] = 1.0 + target = torch.randn(shape, generator=g) + 2.0 * mask + return target, mask + + +def _gaussian(a: np.ndarray, sigma_z: float, sigma: float) -> np.ndarray: + return ndimage.gaussian_filter(a, sigma=(0, 0, sigma_z, sigma, sigma), mode="nearest", truncate=4.0) + + +def _reference(op: BackgroundLowPass, target: torch.Tensor, mask: torch.Tensor) -> tuple[np.ndarray, np.ndarray]: + """``(w, x')`` from scipy: square max filter, Gaussians with ``mode="nearest"``, in float64.""" + x = target.double().numpy() + rz, r = op.dilate_radius_z, op.dilate_radius + dilated = ndimage.maximum_filter( + (mask.numpy() > 0.5).astype(np.float64), size=(1, 1, 2 * rz + 1, 2 * r + 1, 2 * r + 1), mode="constant" + ) + w = _gaussian(dilated, op.sigma_feather_z, op.sigma_feather).clip(0.0, 1.0) + flat = x.copy() # planes without background keep x + for i, j, d in np.ndindex(*x.shape[:3]): + if (dilated[i, j, d] == 0).any(): + flat[i, j, d] = x[i, j, d][dilated[i, j, d] == 0].mean() + if op.sigma_lp is None: + bg = flat + else: + num = _gaussian(x * (1.0 - dilated), op.sigma_lp_z, op.sigma_lp) + den = _gaussian(1.0 - dilated, op.sigma_lp_z, op.sigma_lp) + bg = np.where(den > 1e-6, num / np.maximum(den, 1e-6), flat) + return w, w * x + (1.0 - w) * bg + + +@pytest.mark.parametrize( + ("shape", "sigma_lp", "z_args"), + [ + ((2, 1, 1, 64, 64), 2.0, {}), + ((2, 2, 5, 48, 40), 2.0, {}), + ((1, 1, 6, 40, 40), 2.0, {"sigma_lp_z": 1.0, "sigma_feather_z": 0.5, "dilate_radius_z": 1}), + ((2, 1, 1, 64, 64), None, {}), + ((2, 2, 5, 48, 40), None, {"sigma_feather_z": 0.5, "dilate_radius_z": 1}), + ], + ids=["d1", "per_plane", "with_z", "flat_d1", "flat_with_z"], +) +def test_matches_scipy_reference(shape, sigma_lp, z_args): + """The blend weight and the output equal the scipy.ndimage pipeline, D=1 and D>1, smooth and flat.""" + op = BackgroundLowPass(sigma_lp=sigma_lp, sigma_feather=1.5, dilate_radius=3, **z_args) + target, mask = _square_batch(shape, 12, 28) + mask[:, :, : shape[2] // 2] = 0.0 # planes differ, so Z handling matters + w_ref, out_ref = _reference(op, target, mask) + np.testing.assert_allclose(op.blend_weight(op.dilated_mask(mask)).numpy(), w_ref, atol=1e-6) + np.testing.assert_allclose(op(target, mask).numpy(), out_ref, atol=1e-5) + + +def test_identity_where_w_is_one_and_background_where_w_is_zero(): + """Inside the dilated mask shrunk by the feather radius x' = x; beyond its reach x' = B.""" + op = BackgroundLowPass(sigma_lp=2.0, sigma_feather=2.0, dilate_radius=4) + target, mask = _square_batch((2, 1, 1, 64, 64), 16, 48) + out = op(target, mask) + dilated = op.dilated_mask(mask) + # Dilated square [12, 52); the feather kernel's radius is int(4 * 2 + 0.5) = 8. + inner = (..., slice(20, 44), slice(20, 44)) + torch.testing.assert_close(out[inner], target[inner], rtol=0.0, atol=1e-6) + # Rows 0-3 are > 8 rows from the dilated square: w is exactly 0 there. + assert torch.equal(op.blend_weight(dilated)[..., :4, :], torch.zeros(2, 1, 1, 4, 64)) + assert torch.equal(out[..., :4, :], op.background(target, dilated)[..., :4, :]) + # ... and the background estimate is not the identity there. + assert (out[..., :4, :] - target[..., :4, :]).abs().mean() > 0.3 + + +def test_background_estimate_does_not_leak_the_foreground(): + """On a constant background B is that constant everywhere, even next to a bright blob a plain blur halos.""" + op = BackgroundLowPass(sigma_lp=4.0, sigma_feather=1.0, dilate_radius=2) + mask = torch.zeros((1, 1, 1, 64, 64)) + mask[..., 16:48, 16:48] = 1.0 + target = 0.7 + 10.0 * mask + dilated = op.dilated_mask(mask) + ring = (..., slice(50, 54), slice(16, 48)) # just outside the dilated square [14, 50) + assert torch.equal(dilated[ring], torch.zeros(1, 1, 1, 4, 32)) + plain = _gaussian(target.double().numpy(), 0.0, op.sigma_lp) + assert plain[ring].max() > 2.7 # the halo a plain G_lp(x) would teach + background = op.background(target, dilated) + torch.testing.assert_close(background, torch.full_like(target, 0.7), rtol=0.0, atol=1e-6) + out = op(target, mask) + torch.testing.assert_close(out[dilated == 0], torch.full_like(out[dilated == 0], 0.7), rtol=0.0, atol=1e-6) + + +def test_flat_background_is_the_masked_mean_per_plane(): + """sigma_lp=None: wherever w == 0, x' is one constant per (sample, channel, plane), its background mean.""" + op = BackgroundLowPass(sigma_lp=None, sigma_feather=2.0, dilate_radius=4) + target, mask = _square_batch((2, 2, 3, 64, 64), 16, 48) + mask[0, :, 1] = 0.0 # planes differ + target = target + torch.arange(3.0).reshape(3, 1, 1) + torch.linspace(-1.0, 1.0, 64) # per-plane offset + ramp + out = op(target, mask) + dilated = op.dilated_mask(mask) + zero_w = op.blend_weight(dilated) == 0 + for i, j, d in np.ndindex(2, 2, 3): + expected = target[i, j, d][dilated[i, j, d] == 0].double().mean().item() + values = out[i, j, d][zero_w[i, j, d]] + assert values.numel() > 300 + torch.testing.assert_close(values, torch.full_like(values, expected), rtol=0.0, atol=1e-5) + # An empty mask flattens every plane to its own mean. + flat = op(target, torch.zeros_like(target)) + torch.testing.assert_close(flat, target.mean(dim=(3, 4), keepdim=True).expand_as(target), rtol=0.0, atol=1e-5) + + +@pytest.mark.parametrize("sigma_lp", [None, 8.0], ids=["bgflat", "bglp"]) +def test_backlight_ramp_is_removed_by_flat_and_kept_by_smooth(sigma_lp): + """A linear backlight ramp: bgflat flattens it, bglp (even at a large sigma) keeps it.""" + op = BackgroundLowPass(sigma_lp=sigma_lp, sigma_feather=2.0, dilate_radius=4) + slope = 0.02 + mask = torch.zeros((1, 1, 1, 96, 96)) + mask[..., 40:56, 40:56] = 1.0 + target = slope * torch.arange(96.0) + 5.0 * mask + out = op(target, mask) + zero_w = op.blend_weight(op.dilated_mask(mask)) == 0 + values = out[zero_w] + if sigma_lp is None: + assert torch.unique(values).numel() == 1 + else: + cols = torch.arange(96.0).expand_as(target)[zero_w] + fitted = np.polyfit(cols.numpy(), values.numpy(), 1)[0] + assert 0.8 * slope < fitted < 1.2 * slope + + +def test_background_keeps_the_local_mean(): + """Background = constant + checkerboard: B removes the checkerboard and keeps the constant.""" + op = BackgroundLowPass(sigma_lp=2.0, sigma_feather=2.0, dilate_radius=4) + yy, xx = torch.meshgrid(torch.arange(48), torch.arange(48), indexing="ij") + target = (3.0 + 0.5 * (-1.0) ** (yy + xx)).float().expand(1, 1, 1, 48, 48) + out = op(target, torch.zeros_like(target)) + # Away from the border, where edge replication breaks the checkerboard's alternation. + torch.testing.assert_close(out[..., 8:-8, 8:-8], torch.full((1, 1, 1, 32, 32), 3.0), rtol=0.0, atol=1e-4) + # A constant passes through unchanged whatever the mask. + const = torch.full((2, 1, 3, 32, 32), -0.7) + _, mask = _square_batch(const.shape, 8, 20) + torch.testing.assert_close(op(const, mask), const, rtol=0.0, atol=1e-6) + + +def test_empty_mask_blurs_everything(): + """An empty (or sub-threshold) mask makes B a plain blur of the whole target, and x' = B.""" + op = BackgroundLowPass(sigma_lp=2.0, sigma_feather=2.0, dilate_radius=4) + target, _ = _square_batch((2, 1, 1, 32, 32), 0, 0) + blurred = _gaussian(target.double().numpy(), 0.0, op.sigma_lp) + for mask in (torch.zeros_like(target), torch.full_like(target, 0.4)): + np.testing.assert_allclose(op(target, mask).numpy(), blurred, atol=1e-5) + + +@pytest.mark.parametrize("sigma_feather", [0.5, 1.0, 2.0, 3.0]) +def test_all_foreground_plane_has_w_exactly_one_and_is_returned_unchanged(sigma_feather): + """Under an all-foreground plane w == 1 exactly (not 1 - rounding), so the plane comes back bit-identical.""" + target, mask = _square_batch((2, 1, 3, 32, 32), 8, 20) + mask[:, :, 1] = 1.0 + for sigma_lp in (2.0, None): + op = BackgroundLowPass(sigma_lp=sigma_lp, sigma_feather=sigma_feather, dilate_radius=4) + assert torch.equal(op.blend_weight(op.dilated_mask(mask))[:, :, 1], torch.ones(2, 1, 32, 32)) + out = op(target, mask) + assert torch.equal(out[:, :, 1], target[:, :, 1]) + assert not torch.equal(out[:, :, 0], target[:, :, 0]) + + +@pytest.mark.parametrize("sigma_lp", [2.0, None], ids=["smooth", "flat"]) +def test_patch_without_background_is_returned_unchanged(sigma_lp): + """Where the dilated mask covers the patch, B = x and w == 1: x' = x exactly; other patches are unaffected.""" + op = BackgroundLowPass(sigma_lp=sigma_lp, sigma_feather=2.0, dilate_radius=4) + target, mask = _square_batch((2, 1, 1, 32, 32), 8, 20) + mask[0] = 1.0 + mask[0, ..., 5:7, 9:11] = 0.0 # a hole the dilation fills + dilated = op.dilated_mask(mask) + assert torch.equal(dilated[0], torch.ones_like(dilated[0])) + assert torch.equal(op.blend_weight(dilated)[0], torch.ones_like(dilated[0])) + assert torch.equal(op.background(target, dilated)[0], target[0]) + out = op(target, mask) + assert torch.equal(out[0], target[0]) + assert torch.equal(out[1:], op(target[1:], mask[1:])) + + +def test_thin_background_ring_falls_back_to_the_plane_mean(): + """Pixels the normalized convolution cannot reach take the plane's flat mean; nothing is NaN or Inf.""" + op = BackgroundLowPass(sigma_lp=2.0, sigma_feather=2.0, dilate_radius=1) + target, mask = _square_batch((1, 1, 1, 48, 48), 3, 45) # dilated: [2, 46), a 2-px background ring + dilated = op.dilated_mask(mask) + background = op.background(target, dilated) + den = _gaussian(1.0 - dilated.double().numpy(), 0.0, op.sigma_lp) + unreached = torch.from_numpy(den <= 1e-6) + assert unreached.sum() > 100 # the kernel's support (radius 8) misses the ring from the centre + ring_mean = target[dilated == 0].mean() + torch.testing.assert_close(background[unreached], torch.full_like(background[unreached], ring_mean.item())) + assert torch.isfinite(background).all() + assert torch.isfinite(op(target, mask)).all() + + +def test_planes_are_independent_by_default(): + """With every ``*_z`` at 0, each Z plane is the op applied to that plane alone.""" + op = BackgroundLowPass(sigma_lp=2.0, sigma_feather=1.0, dilate_radius=2) + target, mask = _square_batch((2, 1, 4, 32, 32), 8, 20) + mask[:, :, 1] = 0.0 # planes differ, so a leak across Z would show + out = op(target, mask) + for d in range(4): + plane = op(target[:, :, d : d + 1], mask[:, :, d : d + 1]) + torch.testing.assert_close(out[:, :, d : d + 1], plane, rtol=0.0, atol=1e-6) + + +def test_dtype_and_autocast(): + """Low-precision input comes back in its dtype, computed in float32; autocast changes nothing.""" + op = BackgroundLowPass(sigma_lp=2.0, sigma_feather=2.0, dilate_radius=4) + target, mask = _square_batch((2, 1, 1, 32, 32), 8, 20) + bf16 = target.bfloat16() + out = op(bf16, mask) + assert out.dtype == torch.bfloat16 + assert torch.equal(out, op(bf16.float(), mask).bfloat16()) + with torch.autocast(device_type="cpu", dtype=torch.bfloat16): + autocast_out = op(target, mask) + assert autocast_out.dtype == torch.float32 + assert torch.equal(autocast_out, op(target, mask)) + + +@pytest.mark.skipif(not torch.cuda.is_available(), reason="needs a CUDA device") +@pytest.mark.parametrize("sigma_lp", [2.0, None], ids=["smooth", "flat"]) +def test_cuda_matches_cpu(sigma_lp): + """The GPU path agrees with the CPU path (no convolution backend, so no TF32).""" + op = BackgroundLowPass(sigma_lp=sigma_lp, sigma_feather=2.0, dilate_radius=4) + target, mask = _square_batch((2, 1, 1, 64, 64), 16, 48) + out = op(target.cuda(), mask.cuda()) + assert out.device.type == "cuda" + torch.testing.assert_close(out.cpu(), op(target, mask), rtol=0.0, atol=1e-5) + + +def test_rejects_bad_arguments_and_shapes(): + with pytest.raises(ValueError, match="sigma_lp must be > 0 or None"): + BackgroundLowPass(sigma_lp=0.0, sigma_feather=2.0, dilate_radius=4) + with pytest.raises(ValueError, match="no effect with a flat background"): + BackgroundLowPass(sigma_lp=None, sigma_feather=2.0, dilate_radius=4, sigma_lp_z=1.0) + assert BackgroundLowPass(sigma_lp=float("inf"), sigma_feather=2.0, dilate_radius=4).sigma_lp is None + with pytest.raises(ValueError, match="dilate_radius must be >= 0"): + BackgroundLowPass(sigma_lp=2.0, sigma_feather=2.0, dilate_radius=-1) + with pytest.raises(ValueError, match="sigma_feather_z must be >= 0"): + BackgroundLowPass(sigma_lp=2.0, sigma_feather=2.0, dilate_radius=4, sigma_feather_z=-1.0) + op = BackgroundLowPass(sigma_lp=2.0, sigma_feather=2.0, dilate_radius=4) + with pytest.raises(ValueError, match="must match target"): + op(torch.zeros(1, 1, 1, 8, 8), torch.zeros(1, 1, 1, 8, 4)) + with pytest.raises(ValueError, match=r"\(B, C, D, H, W\)"): + op(torch.zeros(1, 1, 8, 8), torch.zeros(1, 1, 8, 8)) diff --git a/packages/viscy-utils/tests/test_seg_aux_loss.py b/packages/viscy-utils/tests/test_seg_aux_loss.py new file mode 100644 index 000000000..fe986826f --- /dev/null +++ b/packages/viscy-utils/tests/test_seg_aux_loss.py @@ -0,0 +1,619 @@ +"""Unit tests for SegAuxDice.""" + +import numpy as np +import pytest +import torch +from scipy import ndimage + +from viscy_utils.losses import SegAuxDice +from viscy_utils.losses.seg_aux import _masked_median, _quantile_sorted +from viscy_utils.losses.seg_aux_maps import box_max, sauna_signed_map, sauna_weight_map, soft_skeleton, squared_edt + + +def _blob_batch(shape: tuple[int, ...], seed: int = 0) -> tuple[torch.Tensor, torch.Tensor]: + """Target = bright box on a noisy background; mask = the box.""" + g = torch.Generator().manual_seed(seed) + target = 0.1 * torch.randn(shape, generator=g) + mask = torch.zeros(shape) + mask[..., shape[-2] // 4 : shape[-2] // 2, shape[-1] // 4 : shape[-1] // 2] = 1.0 + target = target + 2.0 * mask + return target, mask + + +@pytest.mark.parametrize("shape", [(2, 1, 1, 32, 32), (2, 2, 4, 16, 16)], ids=["2d", "3d"]) +def test_perfect_prediction_beats_perturbed(shape): + target, mask = _blob_batch(shape) + loss_fn = SegAuxDice() + perfect = loss_fn(target.clone(), target, mask) + g = torch.Generator().manual_seed(1) + perturbed = loss_fn(target + 0.5 * torch.randn(shape, generator=g), target, mask) + assert perfect.ndim == 0 + assert perfect < perturbed + blurred_out = loss_fn(torch.zeros(shape), target, mask) + assert perfect < blurred_out + + +def test_gradient_nonzero_for_foreground_far_below_tau(): + """A foreground voxel predicted several knee widths below tau still gets a + gradient pushing it up; v1's clamped sigmoid gave exactly zero there.""" + target, mask = _blob_batch((1, 1, 1, 32, 32)) + flat = target.flatten() + tau = torch.quantile(flat, 1 - mask.mean()) + fg = mask.flatten() > 0.5 + s = 0.1 * (flat[fg].median() - flat[~fg].median()) + pred = target.clone() + fg_idx = (0, 0, 0, 10, 10) + assert mask[fg_idx] == 1 + pred[fg_idx] = tau - 8 * s + pred.requires_grad_(True) + SegAuxDice(c=0.1)(pred, target, mask).backward() + assert pred.grad[fg_idx] < 0 # increasing pred there lowers the loss + + +@pytest.mark.parametrize("a,b", [(3.0, -5.0), (0.01, 1.0), (1.0, 0.7)]) +def test_affine_invariance(a, b): + target, mask = _blob_batch((2, 1, 4, 16, 16)) + pred = target + 0.3 * torch.randn(target.shape, generator=torch.Generator().manual_seed(2)) + loss_fn = SegAuxDice(c=0.1) + ref = loss_fn(pred, target, mask) + moved = loss_fn(a * pred + b, a * target + b, mask) + torch.testing.assert_close(moved, ref, rtol=1e-4, atol=1e-5) + + +def test_masked_median_matches_torch_on_selection(): + g = torch.Generator().manual_seed(7) + values = torch.randn(4, 101, generator=g) + keep = torch.rand(4, 101, generator=g) > 0.6 + got = _masked_median(values, keep) + want = torch.stack([torch.quantile(v[k], 0.5) for v, k in zip(values, keep)]) + torch.testing.assert_close(got, want) + + +def test_mask_darker_than_background_is_excluded(): + target, mask = _blob_batch((1, 1, 1, 32, 32)) + loss, comps = SegAuxDice()(target.clone(), -target, mask, return_components=True) + assert comps["n_valid"] == 0 + + +def test_empty_and_full_masks_are_excluded(): + target, mask = _blob_batch((3, 1, 1, 32, 32)) + mask[1] = 0.0 + mask[2] = 1.0 + pred = target + 0.3 * torch.randn(target.shape, generator=torch.Generator().manual_seed(3)) + loss_fn = SegAuxDice() + loss, comps = loss_fn(pred, target, mask, return_components=True) + only_valid = loss_fn(pred[:1], target[:1], mask[:1]) + assert comps["n_valid"] == 1 + torch.testing.assert_close(loss, only_valid) + torch.testing.assert_close(comps["dice"], loss) + + +def test_all_invalid_is_zero_with_graph(): + target = torch.randn(2, 1, 1, 16, 16) + pred = torch.randn(2, 1, 1, 16, 16, requires_grad=True) + loss, comps = SegAuxDice()(pred, target, torch.zeros_like(target), return_components=True) + assert loss.item() == 0.0 + assert comps["n_valid"] == 0 + assert loss.requires_grad + loss.backward() + assert torch.equal(pred.grad, torch.zeros_like(pred)) + + +def test_constant_target_is_excluded(): + target = torch.ones(1, 1, 1, 16, 16) + mask = torch.zeros_like(target) + mask[..., :8, :] = 1.0 + loss, comps = SegAuxDice()(torch.randn_like(target), target, mask, return_components=True) + assert comps["n_valid"] == 0 + assert loss.item() == 0.0 + + +def test_fractional_mask_is_binarized(): + target, mask = _blob_batch((1, 1, 1, 32, 32)) + pred = target + 0.2 + loss_fn = SegAuxDice() + torch.testing.assert_close(loss_fn(pred, target, mask * 0.8), loss_fn(pred, target, mask)) + + +def test_quantile_matches_torch_quantile(): + rows = torch.randn(4, 1001) + q = torch.tensor([0.0, 0.25, 0.731, 1.0]) + got = _quantile_sorted(rows.sort(-1).values, q) + expected = torch.stack([torch.quantile(rows[i], q[i]) for i in range(4)]) + torch.testing.assert_close(got, expected) + + +def test_quantile_beyond_torch_quantile_size_limit(): + """torch.quantile raises above 2**24 elements; the sort-based path does not.""" + n = 2**24 + 16 + row = torch.arange(n, dtype=torch.float32).unsqueeze(0) + got = _quantile_sorted(row, torch.tensor([0.5])) + torch.testing.assert_close(got, torch.tensor([(n - 1) / 2])) + + +@pytest.mark.parametrize("dtype", [torch.bfloat16, torch.float16]) +def test_autocast_computes_in_float32(dtype): + target, mask = _blob_batch((2, 1, 4, 16, 16)) + pred = (target + 0.3).requires_grad_(True) + ref = SegAuxDice()(pred, target, mask) + with torch.autocast(device_type="cpu", dtype=dtype): + low = SegAuxDice()(pred.to(dtype), target.to(dtype), mask.to(dtype)) + assert low.dtype == torch.float32 + assert torch.isfinite(low) + torch.testing.assert_close(low, ref, rtol=0.05, atol=0.02) + low.backward() + assert torch.isfinite(pred.grad).all() + + +def test_shape_mismatch_raises(): + with pytest.raises(ValueError, match="share a shape"): + SegAuxDice()(torch.zeros(1, 1, 4, 4), torch.zeros(1, 1, 4, 4), torch.zeros(1, 1, 4, 5)) + + +def _mask_disagrees_with_target(shape: tuple[int, ...] = (2, 1, 1, 32, 32)) -> tuple[torch.Tensor, torch.Tensor]: + """Box target plus a bright blob outside the mask: the mask is not a threshold of the target.""" + target, mask = _blob_batch(shape) + target[..., -6:, -6:] += 2.0 + return target, mask + + +def test_target_label_is_minimised_at_pred_equals_target(): + """label='target' is ~0 with zero gradient at pred == target, where label='mask' has a floor.""" + target, mask = _mask_disagrees_with_target() + floor = SegAuxDice(label="mask")(target.clone(), target, mask) + pred = target.clone().requires_grad_(True) + loss = SegAuxDice(label="target")(pred, target, mask) + loss.backward() + assert floor > 0.05 + assert loss < 1e-4 + assert pred.grad.abs().max() < 1e-4 + g = torch.Generator().manual_seed(1) + perturbed = target + 0.5 * torch.randn(target.shape, generator=g) + assert SegAuxDice(label="target")(perturbed, target, mask) > 10 * loss + + +def test_target_label_keeps_the_mask_validity_rule(): + """The mask still decides which patches count: an empty mask is excluded under either label.""" + target, mask = _blob_batch((2, 1, 1, 16, 16)) + mask[0] = 0.0 + for label in ("mask", "target"): + _, valid = SegAuxDice(label=label).per_channel(target, target, mask) + assert valid.tolist() == [[False], [True]] + + +def test_unknown_label_raises(): + with pytest.raises(ValueError, match="label"): + SegAuxDice(label="soft") + + +# ---- Defaults are bit-identical to the pre-extension implementation ---- + +# per_channel(...).dice on _reference_inputs(), computed before weighting/topology existed. +_PRE_EXTENSION_DICE = { + "mask": ["0x1.71c02p-3", "0x1.73a7cp-3", "0x1.37d6bp-3", "0x1.66fff8p-3", "0x1.530968p-3", "0x1.0p+0"], + "target": ["0x1.9c865p-4", "0x1.b3d3ap-4", "0x1.57231p-4", "0x1.a811fp-4", "0x1.80088p-4", "0x1.740c6p-5"], +} + + +def _reference_inputs() -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + g = torch.Generator().manual_seed(123) + shape = (3, 2, 3, 12, 12) + target = torch.randn(shape, generator=g) + mask = (target + 0.3 * torch.randn(shape, generator=g) > 0.5).float() + mask[2, 1] = 0.0 + pred = target + 0.4 * torch.randn(shape, generator=g) + return pred, target, mask + + +@pytest.mark.parametrize("label", ["mask", "target"]) +def test_defaults_are_bit_identical_to_pre_extension(label): + pred, target, mask = _reference_inputs() + loss_fn = SegAuxDice(label=label, weighting="none", topology="none") + dice, valid = loss_fn.per_channel(pred, target, mask) + assert dice.dtype == torch.float32 + assert dice.flatten().tolist() == [float.fromhex(h) for h in _PRE_EXTENSION_DICE[label]] + assert valid.flatten().tolist() == [True] * 5 + [False] + + +# ---- Exact torch EDT ---- + + +def _random_mask(shape: tuple[int, ...], fraction: float, seed: int) -> np.ndarray: + rng = np.random.default_rng(seed) + return rng.random(shape) < fraction + + +@pytest.mark.parametrize( + "shape,spacing", + [ + ((40, 37), (1.0, 1.0)), + ((40, 37), (0.3, 1.7)), + ((9, 21, 18), (1.0, 1.0, 1.0)), + ((9, 21, 18), (0.29, 0.108, 0.108)), + ((1, 30, 25), (0.29, 0.108, 0.108)), + ], + ids=["2d-iso", "2d-aniso", "3d-iso", "3d-aniso", "3d-z1"], +) +@pytest.mark.parametrize("fraction", [0.02, 0.5]) +def test_squared_edt_matches_scipy(shape, spacing, fraction): + seeds = np.stack([_random_mask(shape, fraction, seed) for seed in range(3)]) + seeds[:, (0,) * len(shape)] = True # at least one seed per row + got = squared_edt(torch.from_numpy(seeds), spacing).sqrt().numpy() + want = np.stack([ndimage.distance_transform_edt(~s, sampling=spacing) for s in seeds]) + np.testing.assert_allclose(got, want, rtol=1e-4, atol=1e-6) + + +@pytest.mark.parametrize("max_distance", [0.5, 2.0, 7.5]) +def test_squared_edt_capped_is_exact_below_the_cap(max_distance): + shape, spacing = (9, 41, 38), (0.29, 0.108, 0.108) + seeds = np.stack([_random_mask(shape, 0.01, seed) for seed in range(2)]) + seeds[:, 0, 0, 0] = True + got = squared_edt(torch.from_numpy(seeds), spacing, max_distance=max_distance).sqrt().numpy() + want = np.stack([ndimage.distance_transform_edt(~s, sampling=spacing) for s in seeds]) + np.testing.assert_allclose(got, np.minimum(want, max_distance), rtol=1e-4, atol=1e-6) + + +@pytest.mark.parametrize("shape", [(2, 1, 5, 20, 20), (2, 1, 1, 20, 20), (2, 1, 24, 20)], ids=["3d", "3d-z1", "2d"]) +def test_soft_skeleton_matches_official_values_and_gradients(shape): + """Max-pool morphology (F.max_pool{1,2,3}d) + checkpointing reproduce jocpae/clDice soft_skel.""" + img = torch.rand(shape, generator=torch.Generator().manual_seed(8)) + weights = torch.rand(img.shape, generator=torch.Generator().manual_seed(9)) + a = img.clone().requires_grad_(True) + (soft_skeleton(a, 4) * weights).sum().backward() + b = img.clone().requires_grad_(True) + official = _official_soft_skel(b, 4) + (official * weights).sum().backward() + with torch.no_grad(): + torch.testing.assert_close(soft_skeleton(img, 4), official) + torch.testing.assert_close(a.grad, b.grad) + + +def _official_soft_skel(img: torch.Tensor, iters: int) -> torch.Tensor: + """jocpae/clDice soft_skeleton.py, verbatim for 4D and 5D input.""" + F = torch.nn.functional + + def soft_erode(img): + if len(img.shape) == 4: + p1 = -F.max_pool2d(-img, (3, 1), (1, 1), (1, 0)) + p2 = -F.max_pool2d(-img, (1, 3), (1, 1), (0, 1)) + return torch.min(p1, p2) + p1 = -F.max_pool3d(-img, (3, 1, 1), (1, 1, 1), (1, 0, 0)) + p2 = -F.max_pool3d(-img, (1, 3, 1), (1, 1, 1), (0, 1, 0)) + p3 = -F.max_pool3d(-img, (1, 1, 3), (1, 1, 1), (0, 0, 1)) + return torch.min(torch.min(p1, p2), p3) + + def soft_dilate(img): + if len(img.shape) == 4: + return F.max_pool2d(img, (3, 3), (1, 1), (1, 1)) + return F.max_pool3d(img, (3, 3, 3), (1, 1, 1), (1, 1, 1)) + + def soft_open(img): + return soft_dilate(soft_erode(img)) + + img1 = soft_open(img) + skel = F.relu(img - img1) + for _ in range(iters): + img = soft_erode(img) + img1 = soft_open(img) + delta = F.relu(img - img1) + skel = skel + F.relu(delta - skel * delta) + return skel + + +@pytest.mark.parametrize("windows", [(1, 3, 5), (3, 1, 7), (5, 9, 31), (9, 3, 1)]) +def test_box_max_matches_scipy_maximum_filter(windows): + x = torch.rand(2, 4, 13, 11, generator=torch.Generator().manual_seed(3)) + want = np.stack([ndimage.maximum_filter(r, size=windows, mode="constant", cval=-np.inf) for r in x.numpy()]) + np.testing.assert_array_equal(box_max(x, windows).numpy(), want) + + +def test_squared_edt_without_seeds_is_inf(): + d2 = squared_edt(torch.zeros(2, 4, 5, dtype=torch.bool), (1.0, 1.0)) + assert torch.isinf(d2).all() + + +# ---- SAUNA map ---- + + +def _sauna_reference(gt: np.ndarray) -> np.ndarray: + """SAUNA's combined "h" map, line by line from Oulu-IMEDS/SAUNA + ``generate_uncertainty_masks.py``, with scipy's exact EDT in place of + ``cv2.distanceTransform(..., DIST_L2, DIST_MASK_5)``. ``gt`` is uint8 0/255.""" + + def compute_distance_transform(image): + return ndimage.distance_transform_edt(image).astype(np.float32) + + def do_max_pooling(img_dist): + kernel_size = int(np.ceil(img_dist.max())) + kernel_size = kernel_size + 1 if kernel_size % 2 == 0 else kernel_size + maxpool = torch.nn.MaxPool2d(kernel_size=kernel_size, stride=1, padding=kernel_size // 2) + return maxpool(torch.tensor(img_dist).unsqueeze(0).unsqueeze(0))[0, 0].numpy() + + # extract_boundary_uncertainty_map + img_fg_dist = compute_distance_transform(gt) + fg_max = img_fg_dist.max() + img_bg_dist = -compute_distance_transform(255 - gt) + img_bg_dist[img_bg_dist <= -fg_max] = -fg_max + gt_b = (img_fg_dist + img_bg_dist) / (fg_max + 1e-6) + # extract_thickness_uncertainty_map, target_c_label="h" + img_dist = compute_distance_transform(gt) + thickness_max = img_dist.max() + img_thick_pos = (gt > 0) * do_max_pooling(img_dist) / (thickness_max + 1e-6) + img_bg_dist = compute_distance_transform(255 - gt) + img_bg_dist[img_bg_dist >= fg_max] = fg_max + img_thick_neg = (gt <= 0) * do_max_pooling(img_bg_dist) / (thickness_max + 1e-6) + img_thick_neg = np.clip(img_thick_neg, a_min=0.0, a_max=1.0) + gt_t = np.where(gt > 0, img_thick_pos, img_thick_neg) + # extract_combined_uncertainty_map, target_c_label="h" + gt_c = gt_b.copy() + gt_t_abs = np.abs(gt_t) + fg = (gt_t_abs > 0) & (gt_b > 0) + gt_c[fg] = gt_b[fg] + (1.0 - gt_t[fg]) + bg = (gt_t_abs > 0) & (gt_b < 0) + gt_c[bg] = gt_b[bg] - (1.0 - gt_t[bg]) + return np.clip(gt_c, a_min=-1.0, a_max=1.0) + + +def _disk(canvas: np.ndarray, cy: int, cx: int, r: float) -> None: + yy, xx = np.ogrid[: canvas.shape[0], : canvas.shape[1]] + canvas[(yy - cy) ** 2 + (xx - cx) ** 2 <= r * r] = True + + +def _synthetic_shapes() -> tuple[np.ndarray, dict[str, tuple[int, int]]]: + """Fat disk, 2-px line, two disks across a 2-px gap and a 2-px slit; probe voxels.""" + m = np.zeros((320, 320), dtype=bool) + _disk(m, 50, 50, 20) # rows/cols 30..70 + m[120:122, 20:230] = True # 2-px-wide line + _disk(m, 200, 100, 20) # cols 80..120 + _disk(m, 200, 143, 20) # cols 123..163: gap = cols 121, 122 + m[250:291, 20:100] = True # slit = cols 100, 101 between two 41-px-tall slabs + m[250:291, 102:180] = True + probes = { + "fat_disk_boundary_fg": (50, 70), + "fat_disk_boundary_bg": (50, 71), + "disk_center": (50, 50), + "thin_line": (120, 120), + "gap_center": (200, 121), + "slit_center": (270, 100), + "deep_background": (310, 310), + } + return m, probes + + +def _blob_masks(n: int, size: int, seed: int) -> np.ndarray: + rng = np.random.default_rng(seed) + masks = np.zeros((n, size, size), dtype=bool) + for m in masks: + for _ in range(4): + _disk(m, *rng.integers(0, size, 2), rng.uniform(2, 9)) + row = rng.integers(0, size - 1) + m[row : row + 1, :] = True # 1-px line + return masks + + +def test_sauna_map_matches_sauna_reference(): + synthetic, _ = _synthetic_shapes() + masks = [synthetic, *_blob_masks(4, 64, seed=0)] + for m in masks: + want = _sauna_reference(m.astype(np.uint8) * 255) + got = sauna_signed_map(torch.from_numpy(m)[None], (1.0, 1.0))[0].numpy() + np.testing.assert_allclose(got, want, rtol=1e-4, atol=1e-4) + + +def test_sauna_map_on_synthetic_shapes(capsys): + m, probes = _synthetic_shapes() + y = sauna_signed_map(torch.from_numpy(m)[None], (1.0, 1.0))[0] + values = {name: y[idx].item() for name, idx in probes.items()} + with capsys.disabled(): + print("\nSAUNA y~ on synthetic shapes:", {k: round(v, 4) for k, v in values.items()}) + assert values["disk_center"] == pytest.approx(1.0, abs=1e-4) + assert values["deep_background"] == -1.0 + assert values["thin_line"] > 0.9 + assert values["fat_disk_boundary_fg"] > 0 > values["fat_disk_boundary_bg"] + assert values["gap_center"] < 0 and values["slit_center"] < 0 + # Thick-structure boundaries are the uncertain, down-weighted region: the + # ceil(fg_max)-voxel window reaches ~fg_max / 2 inward, so |y~| ~ 0.5 there. + assert 0.35 < abs(values["fat_disk_boundary_fg"]) < 0.65 + assert 0.35 < abs(values["fat_disk_boundary_bg"]) < 0.65 + assert values["gap_center"] < -0.75 and values["slit_center"] < -0.75 + + +def test_sauna_map_z1_equals_2d_and_degenerate_rows_weigh_one(): + masks = torch.from_numpy(_blob_masks(2, 48, seed=1)) + flat = sauna_signed_map(masks, (1.0, 1.0)) + z1 = sauna_signed_map(masks[:, None], (0.29, 1.0, 1.0))[:, 0] + torch.testing.assert_close(z1, flat) + degenerate = torch.stack([torch.zeros(8, 8, dtype=torch.bool), torch.ones(8, 8, dtype=torch.bool)]) + torch.testing.assert_close(sauna_weight_map(degenerate, (1.0, 1.0)), torch.ones(2, 8, 8)) + + +def test_sauna_weighting_changes_dice_and_stays_finite(): + target, mask = _blob_batch((3, 1, 4, 32, 32)) + mask[1] = 0.0 # invalid patch: weights 1, entry finite and excluded + pred = (target + 0.5 * torch.randn(target.shape, generator=torch.Generator().manual_seed(4))).requires_grad_(True) + plain = SegAuxDice() + sauna = SegAuxDice(weighting="sauna", spacing=(0.29, 0.108, 0.108)) + d_plain, v_plain = plain.per_channel(pred, target, mask) + d_sauna, v_sauna = sauna.per_channel(pred, target, mask) + assert torch.equal(v_plain, v_sauna) + assert torch.isfinite(d_sauna).all() + assert not torch.allclose(d_plain[v_plain], d_sauna[v_sauna]) + loss, comps = sauna(pred, target, mask, return_components=True) + assert comps["n_valid"] == 2 + loss.backward() + assert torch.isfinite(pred.grad).all() + + +# A 1x7 row with a 3-voxel object, spacing 1. By hand: fg_dist = [0,0,1,2,1,0,0], +# bg_dist = [2,1,0,0,0,1,2], fg_max = 2, so gt_b = (fg_dist - bg_dist) / 2. Both +# max-pool windows are ceil(2) -> 3 voxels, which put fg_pool = 2 on every fg voxel +# and bg_pool = 2 on every bg voxel, so gt_t = 1 everywhere and y~ = gt_b. +_ROW_MASK = [0, 0, 1, 1, 1, 0, 0] +_ROW_SIGNED = [-1.0, -0.5, 0.5, 1.0, 0.5, -0.5, -1.0] + + +def test_sauna_weight_map_is_abs_of_hand_computed_map(): + mask = torch.tensor(_ROW_MASK, dtype=torch.bool).reshape(1, 1, 7) + w = sauna_weight_map(mask, (1.0, 1.0))[0, 0] + torch.testing.assert_close(w, torch.tensor([abs(v) for v in _ROW_SIGNED])) + # Background next to the object is uncertain (y~ = -0.5) but still weighted. + assert w[1].item() == pytest.approx(0.5) + + +def test_sauna_weighted_dice_matches_hand_computation(): + target = np.array([0.0, 0.2, 2.0, 3.0, 1.8, 0.4, 0.1]) + pred = np.array([0.5, 1.2, 1.1, 2.5, 0.8, 0.9, -0.3]) + mask = np.array(_ROW_MASK, dtype=float) + w = np.abs(np.array(_ROW_SIGNED)) + c, eps = 0.1, 1e-6 + # tau: target quantile at 1 - 3/7 -> sorted position 3.43, 0.4 + 0.43 * (1.8 - 0.4) = 1.0. + tau = np.quantile(target, 1.0 - mask.mean()) + # s: c * (median fg 2.0 - median bg 0.15) = 0.185. + s = c * (np.median(target[mask > 0]) - np.median(target[mask == 0])) + p = 1.0 / (1.0 + np.exp(-(pred - tau) / s)) + want = 1.0 - 2.0 * (w * p * mask).sum() / ((w * p * p).sum() + (w * mask * mask).sum() + eps) + + def as_input(a: np.ndarray) -> torch.Tensor: + return torch.tensor(a, dtype=torch.float32).reshape(1, 1, 1, 7) + + loss_fn = SegAuxDice(c=c, eps=eps, weighting="sauna", spacing=(1.0, 1.0)) + dice, valid = loss_fn.per_channel(as_input(pred), as_input(target), as_input(mask)) + assert valid.item() + assert dice.item() == pytest.approx(want, rel=1e-5) + + +# ---- clDice ---- + + +def _line_mask(shape: tuple[int, ...] = (1, 1, 1, 48, 48)) -> torch.Tensor: + mask = torch.zeros(shape) + mask[..., 23:25, 4:44] = 1.0 # 2-px-wide line + return mask + + +def _crisp(mask: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]: + """Target = mask + noise; a prediction that is a high-contrast copy of a mask.""" + noise = 0.05 * torch.randn(mask.shape, generator=torch.Generator().manual_seed(5)) + return mask + noise, 3.0 * mask - 1.0 + + +def _skeleton_precision_sensitivity(loss_fn: SegAuxDice, pred, target, mask) -> tuple[float, float]: + """Tprec/Tsens on the loss's own soft prediction, via the module's soft_skeleton.""" + flat_t = target.flatten() + fg = mask.flatten() > 0.5 + tau = torch.quantile(flat_t, 1 - mask.mean()) + s = loss_fn.c * (flat_t[fg].median() - flat_t[~fg].median()) + p = torch.sigmoid((pred - tau) / s)[:, 0] + r = mask[:, 0] + sp = soft_skeleton(p, loss_fn.cldice_iters) + sr = soft_skeleton(r, loss_fn.cldice_iters) + return ((sp * r).sum() / sp.sum()).item(), ((sr * p).sum() / sr.sum()).item() + + +def _line_and_disk_mask() -> torch.Tensor: + mask = _line_mask() + _disk(mask[0, 0, 0].numpy(), 10, 10, 6) # writes through the numpy view + return mask + + +def test_cldice_near_one_for_crisp_copy_of_mask(): + mask = _line_and_disk_mask() + target, pred = _crisp(mask) + pure = SegAuxDice(label="mask", topology="cldice", cldice_alpha=1.0) + one_minus_cl, valid = pure.per_channel(pred, target, mask) + assert valid.all() + assert one_minus_cl.item() < 0.02 + + +def test_cldice_target_label_prefers_pred_equal_target(): + """With label='target' the reference is soft, so clDice < 1 even at pred == target, + but a broken prediction still scores worse.""" + mask = _line_and_disk_mask() + target, _ = _crisp(mask) + pure = SegAuxDice(label="target", topology="cldice", cldice_alpha=1.0) + broken = target.clone() + broken[..., 18:30] = target.min() + assert pure(broken, target, mask) > pure(target.clone(), target, mask) + + +def test_cldice_bridge_lowers_precision_and_break_lowers_sensitivity(): + loss_fn = SegAuxDice(topology="cldice", cldice_alpha=1.0) + two = torch.zeros(1, 1, 1, 48, 64) + _disk(two[0, 0, 0].numpy(), 24, 18, 8) + _disk(two[0, 0, 0].numpy(), 24, 45, 8) # disjoint, gap at cols 27..36 + target, perfect = _crisp(two) + bridged = perfect.clone() + bridged[..., 22:27, 18:46] = 2.0 + prec_ok, sens_ok = _skeleton_precision_sensitivity(loss_fn, perfect, target, two) + prec_br, sens_br = _skeleton_precision_sensitivity(loss_fn, bridged, target, two) + assert prec_br < prec_ok - 0.1 + assert loss_fn(bridged, target, two) > loss_fn(perfect, target, two) + + line = _line_mask() + target, perfect = _crisp(line) + broken = perfect.clone() + broken[..., 18:30] = -1.0 # 12-px break + prec_ok, sens_ok = _skeleton_precision_sensitivity(loss_fn, perfect, target, line) + prec_bk, sens_bk = _skeleton_precision_sensitivity(loss_fn, broken, target, line) + assert sens_bk < sens_ok - 0.1 + assert prec_bk == pytest.approx(prec_ok, abs=0.05) + assert loss_fn(broken, target, line) > loss_fn(perfect, target, line) + + +@pytest.mark.parametrize("weighting", ["none", "sauna"]) +def test_cldice_gradients_finite_and_invalid_excluded(weighting): + target, mask = _blob_batch((3, 1, 4, 32, 32)) + mask[1] = 0.0 + mask[2] = 1.0 + pred = (target + 0.3 * torch.randn(target.shape, generator=torch.Generator().manual_seed(6))).requires_grad_(True) + spacing = (0.29, 0.108, 0.108) if weighting == "sauna" else None + loss_fn = SegAuxDice(topology="cldice", cldice_alpha=0.5, weighting=weighting, spacing=spacing) + loss, comps = loss_fn(pred, target, mask, return_components=True) + assert comps["n_valid"] == 1 + torch.testing.assert_close(loss, loss_fn(pred[:1], target[:1], mask[:1])) + loss.backward() + assert torch.isfinite(pred.grad).all() + assert pred.grad.abs().sum() > 0 + + +def test_cldice_alpha_zero_equals_dice(): + pred, target, mask = _reference_inputs() + plain, _ = SegAuxDice().per_channel(pred, target, mask) + mixed, _ = SegAuxDice(topology="cldice", cldice_alpha=0.0).per_channel(pred, target, mask) + torch.testing.assert_close(mixed, plain) + + +@pytest.mark.parametrize("label", ["mask", "target"]) +def test_extensions_run_under_bf16_autocast(label): + target, mask = _blob_batch((2, 1, 4, 16, 16)) + pred = (target + 0.3).requires_grad_(True) + loss_fn = SegAuxDice(label=label, weighting="sauna", spacing=(0.29, 0.108, 0.108), topology="cldice") + with torch.autocast(device_type="cpu", dtype=torch.bfloat16): + loss = loss_fn(pred.to(torch.bfloat16), target.to(torch.bfloat16), mask.to(torch.bfloat16)) + assert loss.dtype == torch.float32 + assert torch.isfinite(loss) + loss.backward() + assert torch.isfinite(pred.grad).all() + + +@pytest.mark.parametrize( + "kwargs,match", + [ + ({"weighting": "boundary"}, "weighting"), + ({"weighting": "sauna"}, "needs spacing"), + ({"weighting": "sauna", "spacing": (1.0, -1.0)}, "positive"), + ({"spacing": (1.0, 1.0, 1.0)}, "no effect"), + ({"topology": "skeleton"}, "topology"), + ({"topology": "cldice", "cldice_alpha": 1.5}, "cldice_alpha"), + ({"topology": "cldice", "cldice_iters": 0}, "cldice_iters"), + ], +) +def test_invalid_extension_args_raise(kwargs, match): + with pytest.raises(ValueError, match=match): + SegAuxDice(**kwargs) + + +def test_spacing_length_must_match_spatial_dims(): + target, mask = _blob_batch((1, 1, 4, 16, 16)) + with pytest.raises(ValueError, match="spatial dims"): + SegAuxDice(weighting="sauna", spacing=(1.0, 1.0)).per_channel(target, target, mask) diff --git a/packages/viscy-utils/tests/test_seg_consistency_loss.py b/packages/viscy-utils/tests/test_seg_consistency_loss.py new file mode 100644 index 000000000..6217d02b1 --- /dev/null +++ b/packages/viscy-utils/tests/test_seg_consistency_loss.py @@ -0,0 +1,171 @@ +"""Tests for SegConsistencyLoss on a tiny stand-in segmenter (the Cellpose-SAM one is in dynacell).""" + +import pytest +import torch +from torch import Tensor, nn + +from viscy_utils.losses import SegConsistencyLoss +from viscy_utils.losses.seg_consistency import _OTSU_BINS, _binary_kl, _otsu_thresholds, nucleus_area_planes + + +class TinySegmenter(nn.Module): + """Two conv layers to flow (2 ch) + cell-probability logit (1 ch), per-image min-max normalized.""" + + def __init__(self, seed: int = 0) -> None: + super().__init__() + torch.manual_seed(seed) + self.net = nn.Sequential(nn.Conv2d(1, 8, 3, padding=1), nn.Tanh(), nn.Conv2d(8, 3, 3, padding=1)) + + def forward(self, x: Tensor) -> dict[str, Tensor]: + with torch.no_grad(): + lo = x.amin((1, 2, 3), keepdim=True) + hi = x.amax((1, 2, 3), keepdim=True) + y = self.net((x - lo) / (hi - lo + 1e-6)) + return {"flow": y[:, :2], "cellprob_logit": y[:, 2:3]} + + +def _nuclei(shape: tuple[int, ...], seed: int = 0) -> Tensor: + """Bright blobs on noise, peaked in z around a random plane per sample.""" + g = torch.Generator().manual_seed(seed) + b, z, y, x = shape[0], shape[2], shape[3], shape[4] + yy, xx = torch.meshgrid(torch.arange(y), torch.arange(x), indexing="ij") + out = 0.05 * torch.randn(shape, generator=g) + for i in range(b): + zc = float(torch.randint(z // 4, max(z // 4 + 1, 3 * z // 4), (1,), generator=g)) + for _ in range(4): + cy, cx = (torch.rand(2, generator=g) * torch.tensor([y, x])).tolist() + disk = ((yy - cy) ** 2 + (xx - cx) ** 2 < 36).float() + prof = torch.exp(-(((torch.arange(z) - zc) / 2.0) ** 2)) + out[i, 0] += prof[:, None, None] * disk + return out + + +@pytest.mark.parametrize("shape", [(2, 1, 8, 32, 32), (2, 1, 1, 32, 32)], ids=["3d", "z1"]) +def test_zero_at_pred_equals_target_and_positive_otherwise(shape): + target = _nuclei(shape) + loss_fn = SegConsistencyLoss(TinySegmenter()) + assert float(loss_fn(target.clone(), target)) == pytest.approx(0.0, abs=1e-6) + g = torch.Generator().manual_seed(1) + assert float(loss_fn(target + 0.3 * torch.randn(shape, generator=g), target)) > 1e-4 + + +def test_invariant_to_positive_affine_units_of_both_inputs(): + """The segmenter normalizes per image, so a z-scored pred vs a raw target loses nothing.""" + target = _nuclei((2, 1, 6, 32, 32)) + loss_fn = SegConsistencyLoss(TinySegmenter()) + assert float(loss_fn(3.0 * target + 7.0, target)) == pytest.approx(0.0, abs=1e-5) + + +def test_components_match_their_definition(): + target = _nuclei((2, 1, 6, 32, 32)) + pred = target + 0.2 * torch.randn_like(target) + seg = TinySegmenter() + loss_fn = SegConsistencyLoss(seg, crop_size=None) + loss, comps = loss_fn(pred, target, return_components=True) + pred2d, target2d = loss_fn.project(pred, target) + out, ref = seg(pred2d), seg(target2d) + d_flow = ((out["flow"] - ref["flow"]) ** 2).mean() + d_prob = _binary_kl(out["cellprob_logit"], ref["cellprob_logit"]).mean() + torch.testing.assert_close(comps["segcons_flow"], d_flow) + torch.testing.assert_close(comps["segcons_prob"], d_prob) + torch.testing.assert_close(loss, d_flow + d_prob) + assert comps["segcons"] is loss + + +def test_gradient_reaches_pred_only_and_matches_finite_difference(): + target = _nuclei((1, 1, 6, 16, 16)).double() + seg = TinySegmenter().double() + loss_fn = SegConsistencyLoss(seg) + pred = (target + 0.2 * torch.randn_like(target)).requires_grad_(True) + loss_fn(pred, target).backward() + assert torch.isfinite(pred.grad).all() and pred.grad.abs().sum() > 0 + assert all(p.grad is None for p in seg.parameters()) + # Only the 3 focus-slab planes feed the segmenter. + plane = int(nucleus_area_planes(target[:, 0])[0]) + touched = (pred.grad[0, 0].abs().sum((1, 2)) > 0).nonzero().flatten().tolist() + assert set(touched) <= {plane - 1, plane, plane + 1} + # Directional central difference. The segmenter's min/max statistics are stop-gradient, + # so perturb away from the projected image's extreme pixels, which leaves them fixed. + v = torch.zeros_like(pred) + v[0, 0, plane] = torch.randn(16, 16, dtype=torch.float64) + pred2d, _ = loss_fn.project(pred.detach(), target) + for flat_idx in (pred2d.argmax(), pred2d.argmin()): + y, x = divmod(int(flat_idx), 16) + v[0, 0, :, y, x] = 0.0 + eps = 1e-6 + with torch.no_grad(): + num = (loss_fn(pred + eps * v, target) - loss_fn(pred - eps * v, target)) / (2 * eps) + ana = (pred.grad * v).sum() + assert float(num) == pytest.approx(float(ana), rel=1e-3) + + +def test_segmenter_is_frozen_unregistered_and_stays_in_eval(): + seg = TinySegmenter() + loss_fn = SegConsistencyLoss(seg) + parent = nn.Sequential(nn.Linear(2, 2)) + parent.loss = loss_fn + assert all(not k.startswith("loss") for k in parent.state_dict()) + assert list(loss_fn.parameters()) == [] + parent.train() + assert not seg.training + assert not any(p.requires_grad for p in seg.parameters()) + + +def test_crop_size_shapes_what_the_segmenter_sees(): + target = _nuclei((4, 1, 6, 40, 40)) + loss_fn = SegConsistencyLoss(TinySegmenter(), crop_size=24) + pred2d, target2d = loss_fn.project(target, target) + assert pred2d.shape == target2d.shape == (4, 1, 24, 24) + + +def test_rejects_bad_arguments_and_shapes(): + with pytest.raises(ValueError, match="slab_halfwidth"): + SegConsistencyLoss(TinySegmenter(), slab_halfwidth=-1) + with pytest.raises(ValueError, match="crop_size"): + SegConsistencyLoss(TinySegmenter(), crop_size=0) + loss_fn = SegConsistencyLoss(TinySegmenter()) + with pytest.raises(ValueError, match="share a shape"): + loss_fn(torch.zeros(1, 1, 4, 8, 8), torch.zeros(1, 1, 4, 8, 9)) + with pytest.raises(ValueError, match="expected"): + loss_fn(torch.zeros(1, 2, 4, 8, 8), torch.zeros(1, 2, 4, 8, 8)) + with pytest.raises(ValueError, match="expected"): + loss_fn(torch.zeros(1, 1, 8, 8), torch.zeros(1, 1, 8, 8)) + + +def test_nucleus_area_planes_fallbacks(): + assert nucleus_area_planes(torch.zeros(2, 7, 8, 8)).tolist() == [3, 3] + assert nucleus_area_planes(torch.zeros(1, 1, 8, 8)).tolist() == [0] + + +def _otsu_thresholds_bincount(flat: Tensor) -> Tensor: + """The first (bincount-histogram) implementation of ``_otsu_thresholds``, kept as the reference.""" + r = flat.shape[0] + lo = flat.amin(1, keepdim=True) + width = ((flat.amax(1, keepdim=True) - lo) / _OTSU_BINS).clamp_min(torch.finfo(flat.dtype).tiny) + idx = ((flat - lo) / width).floor().long().clamp(0, _OTSU_BINS - 1) + idx += torch.arange(r, device=flat.device).unsqueeze(1) * _OTSU_BINS + hist = torch.bincount(idx.reshape(-1), minlength=r * _OTSU_BINS).reshape(r, _OTSU_BINS).double() + centers = lo.double() + width.double() * (torch.arange(_OTSU_BINS, device=flat.device) + 0.5) + w1 = hist.cumsum(1) + w2 = hist.flip(1).cumsum(1).flip(1) + m1 = (hist * centers).cumsum(1) / w1 + m2 = (hist * centers).flip(1).cumsum(1).flip(1) / w2 + var = w1[:, :-1] * w2[:, 1:] * (m1[:, :-1] - m2[:, 1:]) ** 2 + return centers.gather(1, var.argmax(1, keepdim=True)).squeeze(1).to(flat.dtype) + + +def test_otsu_thresholds_equal_the_bincount_implementation(): + vols = [_nuclei((3, 1, z, 24, 24), seed=z).reshape(3, -1) for z in (1, 5, 16)] + vols.append(torch.rand(2, 1000) ** 3 * 50 - 7) + for flat in vols: + assert torch.equal(_otsu_thresholds(flat), _otsu_thresholds_bincount(flat)) + + +@pytest.mark.skipif(not torch.cuda.is_available(), reason="host-sync detection needs CUDA") +def test_focus_planes_make_no_host_sync(): + vol = _nuclei((2, 1, 8, 32, 32))[:, 0].cuda() + torch.cuda.set_sync_debug_mode("error") + try: + nucleus_area_planes(vol) + finally: + torch.cuda.set_sync_debug_mode("default") diff --git a/packages/viscy-utils/tests/test_spotlight_loss.py b/packages/viscy-utils/tests/test_spotlight_loss.py index 5055ac79f..24214da4c 100644 --- a/packages/viscy-utils/tests/test_spotlight_loss.py +++ b/packages/viscy-utils/tests/test_spotlight_loss.py @@ -251,6 +251,40 @@ def test_partial_mask_ignores_placeholder_channel_in_dice(): assert loss.item() > 0 +def test_return_components_matches_default_with_precomputed_mask(): + """return_components=True: total is bit-identical to the default call, + and the components recombine to the total under lambda_mse.""" + torch.manual_seed(0) + pred = torch.randn(2, 1, 4, 8, 8, requires_grad=True) + target = torch.randn(2, 1, 4, 8, 8).abs() + fg_mask = (target > target.median()).float() + lambda_mse = 0.5 + loss_fn = SpotlightLoss(lambda_mse=lambda_mse, sigmoid_k=-0.95) + + total_default = loss_fn(pred, target, fg_mask=fg_mask) + total, components = loss_fn(pred, target, fg_mask=fg_mask, return_components=True) + + assert torch.equal(total, total_default) + recombined = lambda_mse * components["masked_mse"] + (1 - lambda_mse) * components["dice"] + assert torch.equal(recombined, total) + + +def test_return_components_matches_default_with_otsu_mask(): + """Same guarantee on the runtime-Otsu branch (no fg_mask passed).""" + torch.manual_seed(1) + pred = torch.randn(2, 1, 4, 8, 8, requires_grad=True) + target = torch.randn(2, 1, 4, 8, 8).abs() + lambda_mse = 0.3 + loss_fn = SpotlightLoss(lambda_mse=lambda_mse, sigmoid_k=-0.95, fg_threshold=None) + + total_default = loss_fn(pred, target) + total, components = loss_fn(pred, target, return_components=True) + + assert torch.equal(total, total_default) + recombined = lambda_mse * components["masked_mse"] + (1 - lambda_mse) * components["dice"] + assert torch.equal(recombined, total) + + def test_otsu_per_channel(): """Otsu computes per-(sample, channel) thresholds.""" from viscy_utils.losses.spotlight import _otsu_threshold_batch From 3a09658410a2e122b348ab89991ca4039f54ed44 Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:47:34 -0700 Subject: [PATCH 02/72] feat(viscy-utils): build foreground masks with CLAHE, median and Otsu Port the Spotlight fg-mask recipe from dynacell-models. generate_fg_masks now binarizes a CLAHE-equalized, 5^3-median-filtered volume at an Otsu threshold picked on that volume after a sigma=5 Gaussian; compute_otsu uses the same full-resolution smoothing, so the otsu_grid_spacing parameter is gone from generate_normalization_metadata and VisCyTrainer.preprocess. The median and Gaussian run through cubic on the GPU when cubic and a device are present, else SciPy; cubic stays an optional import. torch is imported lazily so that light callers of write_meta_field do not pay for it. Behavior change: Spotlight masks and Otsu thresholds written by `viscy preprocess` differ from main's. Source on dynacell-models: 40de7939 (#498), d087d962 (#510). Co-Authored-By: Claude Opus 5.5 --- .../viscy-utils/src/viscy_utils/meta_utils.py | 315 ++++++++++++++++-- .../viscy-utils/src/viscy_utils/trainer.py | 4 - packages/viscy-utils/tests/test_meta_utils.py | 71 ++-- .../viscy-utils/tests/test_smooth_gaussian.py | 78 +++++ .../viscy-utils/tests/test_smooth_median.py | 80 +++++ 5 files changed, 495 insertions(+), 53 deletions(-) create mode 100644 packages/viscy-utils/tests/test_smooth_gaussian.py create mode 100644 packages/viscy-utils/tests/test_smooth_median.py diff --git a/packages/viscy-utils/src/viscy_utils/meta_utils.py b/packages/viscy-utils/src/viscy_utils/meta_utils.py index 2dbe70e92..ce949bcae 100644 --- a/packages/viscy-utils/src/viscy_utils/meta_utils.py +++ b/packages/viscy-utils/src/viscy_utils/meta_utils.py @@ -1,14 +1,33 @@ """Normalization metadata generation for OME-Zarr datasets.""" +import logging + import iohub.ngff as ngff import numpy as np from iohub.core.config import TensorStoreConfig from scipy.ndimage import median_filter -from skimage.filters import threshold_otsu +from skimage.exposure import equalize_adapthist +from skimage.filters import gaussian, threshold_otsu from tqdm import tqdm from viscy_utils.mp_utils import get_val_stats +try: + # cubic is how the rest of the codebase reaches the GPU (see + # dynacell.evaluation.metrics): its proxies dispatch on the INPUT ARRAY's + # device, so the same call runs cupyx on a cupy array and scipy on a numpy + # one. Optional here because viscy-utils does not depend on cubic; it ships + # in dynacell's `eval` and `preprocess` extras. + from cubic.cuda import ascupy, asnumpy + from cubic.scipy import ndimage as _cubic_ndimage + from cubic.skimage import exposure as _cubic_exposure + from cubic.skimage import filters as _cubic_filters +except ImportError: # pragma: no cover - exercised by the CPU-only environments + ascupy = None + +_logger = logging.getLogger(__name__) +_BACKEND: dict[str, str] = {} + def write_meta_field(position, metadata, field_name, subfield_name): """Write metadata to position's .zattrs. @@ -58,9 +77,257 @@ def _grid_sample(position, grid_spacing, channel_index): return position["0"].native[:, channel_index, :, ::grid_spacing, ::grid_spacing].read().result() -def generate_normalization_metadata( - zarr_dir, num_workers=4, channel_ids=-1, grid_spacing=32, compute_otsu=False, otsu_grid_spacing=8 -): +def _select_backend(op: str) -> str: + """Pick the array backend for ``op``, logging the choice once per operation.""" + # torch is imported lazily: it costs seconds, and dynacell.evaluation.focus + # imports this module only for write_meta_field. + import torch + + if ascupy is None: + chosen = "scipy" + # Gate the upload on an actual device, as metrics.py does: cubic imports + # cleanly without cupy/cucim and ascupy would raise "GPU requested but not + # available". Falling through to numpy keeps cubic's own CPU path. + elif not torch.cuda.is_available(): + chosen = "cubic-cpu" + else: + chosen = "cubic-gpu" + if _BACKEND.get(op) != chosen: + _BACKEND[op] = chosen + _logger.info("%s: using the %s backend", op, chosen) + return chosen + + +def smooth_median(array, size): + """Median-filter ``array``, on the GPU when cubic and a device are available. + + The mask pass in :func:`generate_fg_masks` spends essentially all of its + time here. Measured on a (44, 624, 924) float32 volume with the (1, 3, 3) + footprint cell.zarr actually uses, on an A40: + + scipy.ndimage.median_filter 5.44 s + cubic.scipy.ndimage.median_filter via ascupy 0.03 s + + Routing through ``cubic.scipy.ndimage`` rather than calling cupyx directly + is the codebase convention (``dynacell.evaluation.metrics`` does the same): + the proxy dispatches on the input array's device, so uploading with + ``ascupy`` selects the GPU implementation and passing plain numpy selects + SciPy, with one call site either way. + + A median filter selects an existing element rather than computing a new + one, so there is no floating-point reassociation and the backends agree + exactly -- pinned by a test on both footprints used here. + + Parameters + ---------- + array : numpy.ndarray + Input array. + size : tuple of int + Filter footprint, one entry per axis of ``array``. + + Returns + ------- + numpy.ndarray + Filtered array, on the host, with the input's dtype and shape. + """ + backend = _select_backend("median filter") + if backend == "scipy": + return median_filter(array, size=size) + if backend == "cubic-cpu": + return asnumpy(_cubic_ndimage.median_filter(array, size=size)) + return asnumpy(_cubic_ndimage.median_filter(ascupy(array), size=size)) + + +def smooth_gaussian(array, sigma): + """Gaussian-blur ``array``, on the GPU when cubic and a device are available. + + Used only to pick the Otsu threshold, never to build the mask: blurring + this hard makes the intensity histogram separable but smears object + boundaries, so the threshold it yields is applied to the median-filtered + image instead. Measured against binarized cpdino segmentations on the 100 + ``dataset_v4/test_cropped`` positions (nucleus, mean over positions): + + threshold from median 5^3 alone, applied to median 5^3 IoU 0.7292 + threshold from median 5^3 + this blur, applied to median IoU 0.7647 + same threshold, applied to the blurred image instead IoU 0.7288 + + Unlike :func:`smooth_median`, a Gaussian computes new values by weighted + summation, so GPU and CPU results are close but not bit-identical; the + tests assert a tolerance rather than equality. + + Parameters + ---------- + array : numpy.ndarray + Input array. + sigma : float or tuple of float + Standard deviation, scalar for all axes or one entry per axis. + + Returns + ------- + numpy.ndarray + Blurred array, on the host, with the input's shape. + """ + backend = _select_backend("gaussian filter") + if backend == "scipy": + return gaussian(array, sigma=sigma, preserve_range=True) + if backend == "cubic-cpu": + return asnumpy(_cubic_filters.gaussian(array, sigma=sigma, preserve_range=True)) + return asnumpy(_cubic_filters.gaussian(ascupy(array), sigma=sigma, preserve_range=True)) + + +_CLAHE_TILE = (50, 120, 120) +_CLAHE_CLIP_LIMIT = 0.015 +_CLAHE_PERCENTILE = 0.1 + + +def equalize_clahe(array, tile_shape=_CLAHE_TILE, clip_limit=_CLAHE_CLIP_LIMIT, nbins=256): + """Contrast-limited adaptive histogram equalization, on the GPU when available. + + ``equalize_adapthist`` takes a tile SIZE, but the number of tiles is what has + to adapt: the established config computes ``shape // (50, 120, 120)`` so tiles + stay roughly constant in pixels across differently-shaped stacks. That floors + to zero in Z for a 44-plane stack, so it is clamped to at least one tile. + + The input is percentile-clipped to ``[0, 1]`` first because + ``equalize_adapthist`` rejects float input outside ``[-1, 1]``. Clipping at + ``_CLAHE_PERCENTILE`` rather than min-max keeps one bright speck from + compressing the rest of the volume toward zero. + + Parameters + ---------- + array : numpy.ndarray + Input ``(Z, Y, X)`` volume. + tile_shape : tuple of int + Target tile size in voxels; the tile COUNT is derived from it. + clip_limit : float + Contrast-limiting threshold. + nbins : int + Histogram bins. + + Returns + ------- + numpy.ndarray + Equalized volume in ``[0, 1]`` -- a different intensity space from the + input, so a threshold taken here is not comparable to a raw one. + """ + lo, hi = np.percentile(array, (_CLAHE_PERCENTILE, 100 - _CLAHE_PERCENTILE)) + scaled = np.clip((array - lo) / (hi - lo), 0.0, 1.0).astype(np.float32) + n_tiles = tuple(max(int(dim // tile), 1) for dim, tile in zip(array.shape, tile_shape)) + kernel = tuple(int(dim // n) for dim, n in zip(array.shape, n_tiles)) + backend = _select_backend("clahe") + if backend == "scipy": + return equalize_adapthist(scaled, kernel_size=kernel, clip_limit=clip_limit, nbins=nbins) + device = scaled if backend == "cubic-cpu" else ascupy(scaled) + return asnumpy(_cubic_exposure.equalize_adapthist(device, kernel_size=kernel, clip_limit=clip_limit, nbins=nbins)) + + +def foreground_mask_from_volume(volume_zyx): + """Binary foreground mask for one ``(Z, Y, X)`` volume. + + The binarization path of the original Spotlight runs + (``scripts/blastoid/preprocess.py::read_preprocess`` in the fnet_astr_vpa + repo): CLAHE, then ``otsu_binarize(filter_size=5)`` -- a 5x5x5 median cube and + ``threshold_otsu``, with no Gaussian, since CLAHE already separates the + histogram. Foreground extraction is a preprocessing choice and not part of + the Spotlight loss, so this is free to differ from :func:`otsu_threshold_from_volume`, + which still supplies the raw-space ``otsu_threshold`` that ``NormalizeSampled`` + subtracts. + + Measured against binarized cpdino segmentations, nucleus channel, on each + sample's own ``nucleus_area`` focus plane (mean IoU / recall): + + iPSC A549 + median 5^3 + gaussian, raw space 0.7637 / 0.7851 0.7713 / 0.7916 + this recipe 0.8262 / 0.8539 0.8898 / 0.9654 + + A Gaussian on top of CLAHE was measured and rejected: it helps iPSC (0.8644) + but hurts A549 (0.8807), while no-blur improves both. The repo's cleanup step + (``min_obj_size=100``, ``max_hole_size=25``) was measured as a no-op here + (+0.0003 and +0.0000) and is omitted. + + Parameters + ---------- + volume_zyx : numpy.ndarray + Full-resolution single-channel volume. + + Returns + ------- + numpy.ndarray + Boolean mask of the input's shape. + """ + # A constant volume (e.g. a blank timepoint) has no structure to segment, and + # its percentile range is zero, which CLAHE's rescale would divide by. + if volume_zyx.min() == volume_zyx.max(): + return np.zeros(volume_zyx.shape, dtype=bool) + equalized = smooth_median(equalize_clahe(volume_zyx), size=_OTSU_MEDIAN_SIZE) + flat = equalized.ravel() + if flat.min() == flat.max(): + return np.zeros(volume_zyx.shape, dtype=bool) + return equalized >= float(threshold_otsu(flat, nbins=256)) + + +_OTSU_MEDIAN_SIZE = 5 +_OTSU_BLUR_SIGMA = 5.0 + + +def otsu_threshold_from_volume(volume_tzyx): + """Compute one FOV's Otsu threshold from a full-resolution ``(T, Z, Y, X)`` volume. + + This is the recipe of the original Spotlight implementation + (``norm_threshold`` in the fnet_astr_vpa notebooks, which resolves to + ``cubic``'s ``downscale_and_filter(downscale_factor=1, filter_size=5)`` then + ``get_threshold_otsu``): a 5x5x5 median cube at full resolution, a sigma=5 + Gaussian, then Otsu. Both filters span Z. On the strongly anisotropic iPSC + stacks that matters a lot -- restricting them to the plane scores worse + than the decimated recipe they replace -- so the footprints are kept + isotropic in voxels rather than matched to physical spacing. + + Measured against binarized cpdino segmentations, nucleus channel, scored on + each sample's own ``nucleus_area`` focus plane (mean IoU / recall), on two + datasets with very different voxel geometry -- iPSC ``test_cropped`` (100 + positions, z=0.290 / xy=0.108) and A549 ``dual_nucl_memb_mock`` (36 + position-timepoint samples, z=0.174 / xy=0.1494): + + iPSC A549 + decimate ::8 + median (1, 3, 3), previous 0.7086 / 0.7309 0.7406 / 0.7558 + this recipe, applied to the median volume 0.7647 / 0.7862 0.7713 / 0.7916 + both footprints restricted to XY 0.6967 / 0.7135 -- + + Otsu erodes on both: precision stays at 0.94-0.97 while recall sits near + 0.76, so the masks are shrunken versions of the truth rather than + mislocated ones, and this recipe buys back recall at near-flat precision. + + ``_OTSU_BLUR_SIGMA`` is the published value, deliberately NOT tuned. A + larger blur scores substantially better on both datasets (iPSC 0.8713 at + sigma=30 and still climbing, A549 0.8649 peaking at sigma=20), but the + optimum is dataset-specific and does not follow from voxel spacing -- a + spacing-derived sigma was measured and refuted. Tuning it would also mean + fitting a training-time parameter on the split the models are scored on, + which biases the Spotlight arms specifically, since the baselines never + read ``fg_mask``. Tune it on a held-out non-eval split or not at all. + + The threshold is pooled over every timepoint and Z plane, so a position + gets one scalar per channel. + + Parameters + ---------- + volume_tzyx : numpy.ndarray + Full-resolution ``(T, Z, Y, X)`` volume for a single channel. + + Returns + ------- + float + The Otsu threshold, or the constant value itself for a constant input, + for which Otsu is undefined. + """ + median = smooth_median(volume_tzyx, size=(1,) + (_OTSU_MEDIAN_SIZE,) * 3) + flat = smooth_gaussian(median, sigma=(0,) + (_OTSU_BLUR_SIGMA,) * 3).ravel() + if flat.min() == flat.max(): + return float(flat.min()) + return float(threshold_otsu(flat)) + + +def generate_normalization_metadata(zarr_dir, num_workers=4, channel_ids=-1, grid_spacing=32, compute_otsu=False): """Generate pixel intensity metadata for normalization. Normalization values are recorded in the image-level metadata in the @@ -79,10 +346,6 @@ def generate_normalization_metadata( compute_otsu : bool, optional Whether to compute Otsu thresholds for foreground estimation, by default False. Required for Spotlight loss. - otsu_grid_spacing : int, optional - Grid spacing for Otsu sampling, by default 8. Denser than the - default ``grid_spacing=32`` to capture inter-cell gaps. A median - filter is applied before thresholding to smooth noise. """ with ngff.open_ome_zarr( zarr_dir, @@ -113,16 +376,10 @@ def generate_normalization_metadata( dataset_sample_values.append(samples) fov_stats = get_val_stats(samples) if compute_otsu: - otsu_samples = _grid_sample(pos, otsu_grid_spacing, channel_index) - smoothed = median_filter(otsu_samples, size=(1, 1, 3, 3)) - flat = smoothed.ravel() - # Otsu's method is undefined for constant-valued inputs. - # Use the constant value itself so generate_fg_masks marks - # nothing as foreground (no meaningful structure to supervise). - if flat.min() == flat.max(): - fov_stats["otsu_threshold"] = float(flat.min()) - else: - fov_stats["otsu_threshold"] = float(threshold_otsu(flat)) + # Full resolution: the sigma=5 blur below is defined in source + # pixels, so thresholding a decimated grid would scale it by the + # stride and erase the effect. + fov_stats["otsu_threshold"] = otsu_threshold_from_volume(_grid_sample(pos, 1, channel_index)) fov_statistics = {"fov_statistics": fov_stats} fov_timepoint_statistics = {} for t in range(num_timepoints): @@ -164,12 +421,16 @@ def generate_fg_masks( """Precompute binary foreground masks from Otsu thresholds. For each FOV and specified channel, loads the full-resolution image one - timepoint at a time, smooths with the same median filter used for Otsu - thresholding, and writes the binary mask as a zarr array alongside the - image data. + timepoint at a time and binarizes it with + :func:`foreground_mask_from_volume`, writing the result as a zarr array + alongside the image data. - Requires ``generate_normalization_metadata`` with ``compute_otsu=True`` - to have been run first (Otsu thresholds must be stored in zattrs). + Does NOT read ``otsu_threshold``. That value is computed in raw intensity + units for ``NormalizeSampled`` to subtract, whereas this pass thresholds in + CLAHE's equalized ``[0, 1]`` space, so the two are not interchangeable and + the mask is deliberately not derivable from the stored scalar. Running + ``generate_normalization_metadata`` with ``compute_otsu=True`` is still + required for Spotlight, but for normalization rather than for masking. Parameters ---------- @@ -217,11 +478,7 @@ def generate_fg_masks( mask_arr[:, c] = 1 # Compute and write target channel masks per timepoint - for ch_name, ch_idx in zip(channel_names, channel_indices): - norm = pos.zattrs["normalization"][ch_name]["fov_statistics"] - otsu_threshold = norm["otsu_threshold"] - + for ch_idx in channel_indices: for t in range(t_total): data = img_arr[t, ch_idx].astype(np.float32) - smoothed = median_filter(data, size=(1, 3, 3)) - mask_arr[t, ch_idx] = (smoothed >= otsu_threshold).astype(np.uint8) + mask_arr[t, ch_idx] = foreground_mask_from_volume(data).astype(np.uint8) diff --git a/packages/viscy-utils/src/viscy_utils/trainer.py b/packages/viscy-utils/src/viscy_utils/trainer.py index be5bcb653..dfa2dbe8e 100644 --- a/packages/viscy-utils/src/viscy_utils/trainer.py +++ b/packages/viscy-utils/src/viscy_utils/trainer.py @@ -26,7 +26,6 @@ def preprocess( num_workers: int = 1, block_size: int = 32, compute_otsu: bool = False, - otsu_grid_spacing: int = 8, compute_fg_masks: bool = False, fg_mask_channels: list[str] | None = None, fg_mask_key: str = "fg_mask", @@ -47,8 +46,6 @@ def preprocess( compute_otsu : bool, optional Whether to compute Otsu thresholds for Spotlight loss, by default False. - otsu_grid_spacing : int, optional - Grid spacing for Otsu sampling (denser than default), by default 8. compute_fg_masks : bool, optional Whether to precompute binary foreground masks from Otsu thresholds, by default False. Requires ``compute_otsu=True``. @@ -75,7 +72,6 @@ def preprocess( channel_ids=channel_indices, grid_spacing=block_size, compute_otsu=compute_otsu, - otsu_grid_spacing=otsu_grid_spacing, ) if compute_fg_masks: if not compute_otsu: diff --git a/packages/viscy-utils/tests/test_meta_utils.py b/packages/viscy-utils/tests/test_meta_utils.py index 08ed7e5b2..fb8646052 100644 --- a/packages/viscy-utils/tests/test_meta_utils.py +++ b/packages/viscy-utils/tests/test_meta_utils.py @@ -1,8 +1,10 @@ +import warnings + import numpy as np import pytest from iohub import open_ome_zarr -from viscy_utils.meta_utils import generate_fg_masks, generate_normalization_metadata +from viscy_utils.meta_utils import foreground_mask_from_volume, generate_fg_masks, generate_normalization_metadata GRID_SPACING = 8 @@ -103,9 +105,7 @@ def test_normalization_metadata_keys(small_hcs_dataset): def test_compute_otsu_stores_threshold(bimodal_hcs_dataset): """compute_otsu=True stores otsu_threshold in fov_statistics.""" - generate_normalization_metadata( - bimodal_hcs_dataset, num_workers=1, grid_spacing=GRID_SPACING, compute_otsu=True, otsu_grid_spacing=4 - ) + generate_normalization_metadata(bimodal_hcs_dataset, num_workers=1, grid_spacing=GRID_SPACING, compute_otsu=True) with open_ome_zarr(bimodal_hcs_dataset, mode="r") as plate: for _, fov in plate.positions(): @@ -117,9 +117,7 @@ def test_compute_otsu_stores_threshold(bimodal_hcs_dataset): def test_compute_otsu_threshold_separates_bimodal(bimodal_hcs_dataset): """Otsu threshold on bimodal fluorescence falls between the two modes.""" - generate_normalization_metadata( - bimodal_hcs_dataset, num_workers=1, grid_spacing=GRID_SPACING, compute_otsu=True, otsu_grid_spacing=4 - ) + generate_normalization_metadata(bimodal_hcs_dataset, num_workers=1, grid_spacing=GRID_SPACING, compute_otsu=True) with open_ome_zarr(bimodal_hcs_dataset, mode="r") as plate: for _, fov in plate.positions(): @@ -141,9 +139,7 @@ def test_compute_otsu_false_omits_threshold(small_hcs_dataset): def test_generate_fg_masks_stores_mask(bimodal_hcs_dataset): """generate_fg_masks stores a uint8 binary mask array per position.""" - generate_normalization_metadata( - bimodal_hcs_dataset, num_workers=1, grid_spacing=GRID_SPACING, compute_otsu=True, otsu_grid_spacing=4 - ) + generate_normalization_metadata(bimodal_hcs_dataset, num_workers=1, grid_spacing=GRID_SPACING, compute_otsu=True) generate_fg_masks(bimodal_hcs_dataset, channel_names=["Fluorescence"]) with open_ome_zarr(bimodal_hcs_dataset, mode="r") as plate: @@ -158,9 +154,7 @@ def test_generate_fg_masks_stores_mask(bimodal_hcs_dataset): def test_generate_fg_masks_separates_bimodal(bimodal_hcs_dataset): """Fluorescence mask marks the bright half as foreground.""" - generate_normalization_metadata( - bimodal_hcs_dataset, num_workers=1, grid_spacing=GRID_SPACING, compute_otsu=True, otsu_grid_spacing=4 - ) + generate_normalization_metadata(bimodal_hcs_dataset, num_workers=1, grid_spacing=GRID_SPACING, compute_otsu=True) generate_fg_masks(bimodal_hcs_dataset, channel_names=["Fluorescence"]) with open_ome_zarr(bimodal_hcs_dataset, mode="r") as plate: @@ -173,18 +167,55 @@ def test_generate_fg_masks_separates_bimodal(bimodal_hcs_dataset): assert (fov["fg_mask"][:, phase_idx] == 1).all() -def test_generate_fg_masks_requires_otsu(bimodal_hcs_dataset): - """generate_fg_masks raises KeyError without prior Otsu computation.""" - with pytest.raises(KeyError): - generate_fg_masks(bimodal_hcs_dataset, channel_names=["Fluorescence"]) +def test_generate_fg_masks_does_not_need_otsu(bimodal_hcs_dataset): + """Masking no longer reads otsu_threshold, so it runs without one. + + The mask is thresholded in CLAHE's equalized [0, 1] space while + otsu_threshold is in raw intensity units for NormalizeSampled to subtract. + Deriving the mask from that scalar would be a unit error, so the dependency + is gone -- and this pins it gone, because the previous contract (raise + KeyError) was the opposite assertion. + """ + generate_fg_masks(bimodal_hcs_dataset, channel_names=["Fluorescence"]) + + with open_ome_zarr(bimodal_hcs_dataset, mode="r") as plate: + ch_idx = plate.channel_names.index("Fluorescence") + for _, fov in plate.positions(): + # The stats pass never ran, so there is no normalization block at + # all -- masking cannot have consulted a threshold that is absent. + assert "normalization" not in fov.zattrs + assert fov["fg_mask"][:, ch_idx].sum() > 0 + + +def test_fg_mask_separates_the_bimodal_channel(bimodal_hcs_dataset): + """The mask must track the bright half, not merely be non-empty. + + The fixture's Fluorescence channel is bright on y >= 32 only, so a mask that + covers everything (or the wrong half) still passes a `sum() > 0` check. + """ + generate_fg_masks(bimodal_hcs_dataset, channel_names=["Fluorescence"]) + + with open_ome_zarr(bimodal_hcs_dataset, mode="r") as plate: + ch_idx = plate.channel_names.index("Fluorescence") + for _, fov in plate.positions(): + mask = np.asarray(fov["fg_mask"][0, ch_idx]) + bright, dark = mask[:, 32:, :].mean(), mask[:, :32, :].mean() + assert bright > 0.9, f"bright half under-covered: {bright}" + assert dark < 0.1, f"dark half over-covered: {dark}" def test_generate_fg_masks_no_overwrite(bimodal_hcs_dataset): """generate_fg_masks raises FileExistsError on re-run.""" - generate_normalization_metadata( - bimodal_hcs_dataset, num_workers=1, grid_spacing=GRID_SPACING, compute_otsu=True, otsu_grid_spacing=4 - ) + generate_normalization_metadata(bimodal_hcs_dataset, num_workers=1, grid_spacing=GRID_SPACING, compute_otsu=True) generate_fg_masks(bimodal_hcs_dataset, channel_names=["Fluorescence"]) with pytest.raises(FileExistsError): generate_fg_masks(bimodal_hcs_dataset, channel_names=["Fluorescence"]) + + +def test_constant_volume_gives_an_empty_mask_without_warnings(): + """A blank timepoint is all background, reached by the explicit guard rather than a NaN.""" + with warnings.catch_warnings(): + warnings.simplefilter("error") + mask = foreground_mask_from_volume(np.full((4, 64, 64), 3.0, dtype=np.float32)) + assert mask.dtype == bool and mask.shape == (4, 64, 64) and not mask.any() diff --git a/packages/viscy-utils/tests/test_smooth_gaussian.py b/packages/viscy-utils/tests/test_smooth_gaussian.py new file mode 100644 index 000000000..22b6b5f94 --- /dev/null +++ b/packages/viscy-utils/tests/test_smooth_gaussian.py @@ -0,0 +1,78 @@ +"""Tests for the GPU-dispatching Gaussian blur behind the Otsu threshold. + +Unlike the median, a Gaussian computes new values by weighted summation, so +the backends reassociate floating-point additions differently and agree only +to a tolerance -- these tests assert closeness, not equality. The blur only +ever picks a threshold, so a last-bit difference cannot change a mask except +for a voxel sitting exactly on the threshold. + +Dispatch goes through ``cubic.skimage.filters``, whose proxies select the +backend from the input array's device. The GPU tests are skipped, not failed, +when cubic or a device is absent: viscy-utils does not depend on cubic, which +ships in dynacell's eval/preprocess extras. +""" + +import numpy as np +import pytest +from skimage.filters import gaussian + +from viscy_utils.meta_utils import _OTSU_BLUR_SIGMA, otsu_threshold_from_volume, smooth_gaussian + +# The footprint otsu_threshold_from_volume uses: no blur across T, sigma in ZYX. +_SIGMA = (0,) + (_OTSU_BLUR_SIGMA,) * 3 +_SHAPE = (2, 8, 16, 24) + + +def _volume(seed: int) -> np.ndarray: + """Bimodal float32 array, so Otsu has two populations to separate.""" + rng = np.random.default_rng(seed) + arr = rng.normal(400.0, 20.0, size=_SHAPE).astype(np.float32) + arr[..., 4:12, 6:18] += 300.0 + return arr + + +def test_matches_skimage_on_the_cpu_path() -> None: + """Whichever backend runs, the result matches skimage's to float32 tolerance.""" + arr = _volume(seed=0) + expected = gaussian(arr, sigma=_SIGMA, preserve_range=True) + assert np.allclose(smooth_gaussian(arr, sigma=_SIGMA), expected, rtol=1e-5, atol=1e-4) + + +def test_preserve_range_is_honoured() -> None: + """Without preserve_range skimage rescales via img_as_float, moving the threshold. + + The blurred values must stay in the input's intensity units, because the + threshold Otsu picks from them is written to zattrs and later compared + against raw voxel values. + """ + arr = _volume(seed=1) + out = smooth_gaussian(arr, sigma=_SIGMA) + assert out.min() > 300.0 + assert out.max() < 800.0 + + +def test_cubic_gpu_and_cpu_agree() -> None: + """Pin cubic's GPU blur against skimage, the assumption the speedup rests on.""" + pytest.importorskip("cubic") + torch = pytest.importorskip("torch") + from cubic.cuda import ascupy, asnumpy + from cubic.skimage import filters as cubic_filters + + if not torch.cuda.is_available(): + pytest.skip("no CUDA device available") + arr = _volume(seed=2) + on_gpu = asnumpy(cubic_filters.gaussian(ascupy(arr), sigma=_SIGMA, preserve_range=True)) + assert np.allclose(on_gpu, gaussian(arr, sigma=_SIGMA, preserve_range=True), rtol=1e-4, atol=1e-3) + + +def test_threshold_separates_a_bimodal_volume() -> None: + """The whole recipe, end to end: the threshold must land between the two modes.""" + arr = _volume(seed=3) + threshold = otsu_threshold_from_volume(arr) + assert 400.0 < threshold < 700.0 + + +def test_constant_volume_returns_its_constant() -> None: + """Otsu is undefined for a constant input; the recipe returns the value itself.""" + arr = np.full(_SHAPE, 42.0, dtype=np.float32) + assert otsu_threshold_from_volume(arr) == pytest.approx(42.0) diff --git a/packages/viscy-utils/tests/test_smooth_median.py b/packages/viscy-utils/tests/test_smooth_median.py new file mode 100644 index 000000000..1cd5dba97 --- /dev/null +++ b/packages/viscy-utils/tests/test_smooth_median.py @@ -0,0 +1,80 @@ +"""Tests for the GPU-dispatching median filter behind the fg_mask pass. + +The filter is the whole cost of both Otsu passes -- 42.8 s of the 43.9 s a +(44, 624, 924) float32 volume takes on the CPU with the 5x5x5 cube, against +~0.1 s on an A40 including both transfers. That only makes it a safe swap if +the two backends agree exactly, which they should: a median filter SELECTS an +existing element rather than computing a new one, so there is no +floating-point reassociation for the backends to disagree about. + +Dispatch goes through ``cubic.scipy.ndimage``, whose proxies select the +backend from the input array's device -- the same route +``dynacell.evaluation.metrics`` takes. The GPU test is skipped, not failed, +when cubic or a device is absent: viscy-utils does not depend on cubic, which +ships in dynacell's eval/preprocess extras. +""" + +import numpy as np +import pytest +from scipy.ndimage import median_filter + +from viscy_utils.meta_utils import smooth_median + +# The two footprints the callers actually use: the 4-D (1, 5, 5, 5) of +# otsu_threshold_from_volume over a (T, Z, Y, X) volume, and the bare 5 cube +# generate_fg_masks applies per timepoint to (Z, Y, X). Both span Z, which is +# where the accuracy comes from -- restricting them to the plane scores worse +# than the decimated (1, 3, 3) recipe they replaced. +_SIZES = [(1, 5, 5, 5), 5] +_SHAPES = {(1, 5, 5, 5): (2, 8, 16, 24), 5: (8, 16, 24)} + + +def _volume(size, seed: int) -> np.ndarray: + """Bimodal float32 array of matching rank, so the filter has structure to act on.""" + rng = np.random.default_rng(seed) + arr = rng.normal(400.0, 20.0, size=_SHAPES[size]).astype(np.float32) + arr[..., 4:12, 6:18] += 300.0 + return arr + + +@pytest.mark.parametrize("size", _SIZES) +def test_matches_scipy_on_the_cpu_path(size) -> None: + """Whichever backend runs, the result equals SciPy's exactly.""" + arr = _volume(size, seed=0) + assert np.array_equal(smooth_median(arr, size=size), median_filter(arr, size=size)) + + +@pytest.mark.parametrize("size", _SIZES) +def test_cubic_gpu_and_cpu_agree_bitwise(size) -> None: + """Pin cubic's GPU path == SciPy, the assumption the speedup rests on.""" + pytest.importorskip("cubic") + torch = pytest.importorskip("torch") + from cubic.cuda import ascupy, asnumpy + from cubic.scipy import ndimage as cubic_ndimage + + if not torch.cuda.is_available(): + pytest.skip("no CUDA device available") + arr = _volume(size, seed=1) + on_gpu = asnumpy(cubic_ndimage.median_filter(ascupy(arr), size=size)) + assert np.array_equal(on_gpu, median_filter(arr, size=size)) + + +@pytest.mark.parametrize("size", _SIZES) +def test_cubic_cpu_path_agrees_bitwise(size) -> None: + """A numpy input must route to cubic's CPU path and still match SciPy.""" + pytest.importorskip("cubic") + from cubic.cuda import asnumpy + from cubic.scipy import ndimage as cubic_ndimage + + arr = _volume(size, seed=3) + on_cpu = asnumpy(cubic_ndimage.median_filter(arr, size=size)) + assert np.array_equal(on_cpu, median_filter(arr, size=size)) + + +def test_preserves_dtype_and_shape() -> None: + """The mask pass casts the result to uint8, so dtype must not drift to float64.""" + arr = _volume(5, seed=2) + out = smooth_median(arr, size=5) + assert out.dtype == arr.dtype + assert out.shape == arr.shape + assert isinstance(out, np.ndarray) From e461edc63eff863975b8ac86a10079d5628cc2a9 Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:47:45 -0700 Subject: [PATCH 03/72] feat(viscy-utils): make prediction writes resumable, identified and write-once Port the HCSPredictionWriter and prediction_metadata work from dynacell-models: - z_reduction="center" and z_planes (slab-only predicts write only the planes they predicted, and record them); - per-FOV completion markers and the checkpoint/settings identity that predict resume and the eval caches key on (prediction_metadata.py); - refuse writes into an existing store when a FOV outside the run has unmarked prediction channels, or when the array would grow; - assemble each volume in memory and write it once on a background thread (bytes unchanged); - raise NotImplementedError when trainer.world_size > 1, instead of letting ranks race on one store. Source on dynacell-models: 2b848a65, 1be44667, 74fa18a4 (#497), 8e414988 (#511), 996adb47 (#526), 6c83fff4 (#531), 8e74a7eb (#532). Co-Authored-By: Claude Opus 5.5 --- .../callbacks/prediction_writer.py | 491 ++++++++- .../src/viscy_utils/prediction_metadata.py | 483 +++++++++ .../tests/test_prediction_metadata.py | 202 ++++ .../tests/test_prediction_writer.py | 958 +++++++++++++++++- 4 files changed, 2116 insertions(+), 18 deletions(-) create mode 100644 packages/viscy-utils/src/viscy_utils/prediction_metadata.py create mode 100644 packages/viscy-utils/tests/test_prediction_metadata.py diff --git a/packages/viscy-utils/src/viscy_utils/callbacks/prediction_writer.py b/packages/viscy-utils/src/viscy_utils/callbacks/prediction_writer.py index f7f778b91..6716851b5 100644 --- a/packages/viscy-utils/src/viscy_utils/callbacks/prediction_writer.py +++ b/packages/viscy-utils/src/viscy_utils/callbacks/prediction_writer.py @@ -6,8 +6,10 @@ from __future__ import annotations +import functools import logging import os +from concurrent.futures import Future, ThreadPoolExecutor from typing import TYPE_CHECKING, Literal, Optional, Sequence import numpy as np @@ -17,6 +19,21 @@ from lightning.pytorch.callbacks import BasePredictionWriter from numpy.typing import DTypeLike, NDArray +from viscy_utils.prediction_metadata import ( + PREDICTION_COMPLETE_KEY, + canonical_z_planes, + checkpoint_signature, + completion_marker, + mark_complete, + mark_started, + outruns, + predicted_z_planes, + prediction_run, + record_z_planes, + same_run, + tzyx_shape, + z_planes_sha256_12, +) from viscy_utils.tensor_utils import to_numpy if TYPE_CHECKING: @@ -78,8 +95,8 @@ def _blend_in( ) -> torch.Tensor | NDArray: """Blend a new stack into an old stack over a Z range with linear feathering. - Supports both torch tensors (5D: B,C,Z,Y,X) for in-memory sliding window - prediction and numpy arrays (4D: C,Z,Y,X) for out-of-core HCSPredictionWriter. + Supports torch tensors (B,C,Z,Y,X or C,Z,Y,X) for in-memory prediction and + numpy arrays (C,Z,Y,X) for HCSPredictionWriter's per-window writes. Parameters ---------- @@ -104,16 +121,60 @@ def _blend_in( factors.append(min(i + 1, samples)) _logger.debug(f"Blending with factors {factors}.") if isinstance(old_stack, torch.Tensor): - factors = torch.tensor(factors, dtype=old_stack.dtype, device=old_stack.device) - factors = factors.view(1, 1, -1, 1, 1) + factors = _torch_factors(tuple(factors), old_stack.dtype, old_stack.device) else: factors = np.array(factors)[np.newaxis, :, np.newaxis, np.newaxis] return old_stack * (factors - 1) / factors + new_stack / factors +@functools.lru_cache(maxsize=64) +def _torch_factors(factors: tuple[int, ...], dtype: torch.dtype, device: torch.device) -> torch.Tensor: + """Blend factors as a ``(Z, 1, 1)`` tensor, cached: a per-window host-to-device copy would sync every window.""" + # A normal tensor even when first built under predict's inference mode, so a later + # grad-enabled caller can still save it for backward. + with torch.inference_mode(False): + return torch.tensor(factors, dtype=dtype, device=device).view(-1, 1, 1) + + +def _store_into(volume: torch.Tensor, z_slice: slice, planes: torch.Tensor) -> None: + """Write ``planes`` into ``volume[:, z_slice]``, rounding to the volume dtype as numpy does. + + Torch rounds to float32 and float64 exactly like numpy. It converts float64 to + float16 through float32, though, which can round twice, so other dtypes are cast + by numpy on the host. + + Parameters + ---------- + volume : torch.Tensor + ``(C, Z, Y, X)`` volume buffer. + z_slice : slice + Planes of ``volume`` to write. + planes : torch.Tensor + ``(C, Z, Y, X)`` planes, on the volume's device. + """ + if volume.dtype not in (torch.float32, torch.float64) and planes.dtype != volume.dtype: + cast = planes.cpu().numpy().astype(torch.empty(0, dtype=volume.dtype).numpy().dtype) + planes = torch.from_numpy(cast).to(volume.device) + volume[:, z_slice] = planes + + class HCSPredictionWriter(BasePredictionWriter): """Callback to store virtual staining predictions as HCS OME-Zarr. + Single-process only: completion is tracked per process and channels are + appended to the store without cross-rank coordination, so a multi-device + predict is refused before the store is opened. + + Each (position, timepoint) volume is assembled in memory from its depth + windows and written once, when its last window arrives (or at predict end), + instead of a zarr read-modify-write per window; the stored bytes are the + same. The write runs on a background thread while the next volume is + predicted, one at a time and in order; a FOV's completion marker is written + on that thread after its last volume, and a write error is raised at the + next batch or at predict end. ``write_input`` and plane-restricted predicts (``predict_z_planes``) keep + the per-window writes: the first stores slices beside each window, and the + second writes single planes, which a volume flush would fill in between. + Parameters ---------- output_store : str @@ -126,6 +187,52 @@ class HCSPredictionWriter(BasePredictionWriter): (must be writing to a new store), by default False. write_interval : {'batch', 'epoch', 'batch_and_epoch'}, optional When to write, by default "batch". + z_reduction : {'blend', 'center'}, optional + How to combine the depth windows that cover one output plane, by + default "blend". + + ``'blend'`` feathers each window in with :func:`_blend_in`. With the + usual stride-1 depth windows that recurrence is the incremental mean, + so every plane ends up the *unweighted mean of ``z_window_size`` + forward passes*. That is a real sharpness cost for a generative model: + on an iPSC-trained pix2pix3d membrane prediction the mean over 8 + windows halves the mid-band power relative to a single pass + (0.045 -> 0.021 of ground truth), and because all 8 share one XY grid + it cancels none of the decoder's XY lattice. + + ``'center'`` writes each window from its center plane onward, so a + later window overwrites everything but that center plane and the + volume is assembled one plane per forward pass with no averaging. + The leading ``z_window_size // 2`` planes come from the first window + and the trailing ``z_window_size - 1 - z_window_size // 2`` from the + last, since no window is centered on them. For odd ``z_window_size`` + that trailing count equals ``z_window_size // 2`` -- at ``w=5`` it is + 2, not 1. Every dynacell leaf that sets ``z_window_size`` uses an odd + value. + + Both modes assume windows arrive in increasing ``z`` order within a + ``(position, timepoint)`` -- ``'blend'`` because its factors are + derived from ``z_slice.start``, ``'center'`` because it relies on + last-write-wins. The predict dataloader is sequential and iterates + ``z`` innermost, which is what makes that hold. + checkpoint_path : str or None, optional + Checkpoint the model predicts with. Its path and content hash are + recorded in every FOV's completion marker, so a resume can tell + predictions made with different weights apart and refuses to mix + them in one store. The file's size and mtime are taken when the + writer is constructed -- the same instantiation pass that loads the + model's weights -- and ``on_predict_start`` refuses a file changed + since, so the recorded hash names the bytes the model loaded rather + than whatever sits at the path later. Default None records no + checkpoint. + settings_sha256_12 : str or None, optional + Hash of the other settings that shape the predicted voxels (model + inference arguments, input normalization, precision), recorded in the + marker alongside the checkpoint so a resume with the same weights but + other settings is refused as well. The submitter computes it from the + resolved config (``submit_benchmark_job.prediction_settings_sha256_12``); + the writer cannot derive it from live objects. Default None records + none. """ def __init__( @@ -134,12 +241,24 @@ def __init__( overwrite: bool = False, write_input: bool = False, write_interval: Literal["batch", "epoch", "batch_and_epoch"] = "batch", + z_reduction: Literal["blend", "center"] = "blend", + checkpoint_path: str | None = None, + settings_sha256_12: str | None = None, ) -> None: super().__init__(write_interval) + if z_reduction not in ("blend", "center"): + raise ValueError(f"z_reduction must be 'blend' or 'center', got {z_reduction!r}") self.output_store = output_store self.overwrite = overwrite self.write_input = write_input + self.z_reduction = z_reduction + self.checkpoint_path = checkpoint_path + self._checkpoint_signature = None if checkpoint_path is None else checkpoint_signature(checkpoint_path) + self.settings_sha256_12 = settings_sha256_12 self._dataset_scale = None + # Set by on_predict_start; None until then, so a failure during setup closes nothing. + self.plate: Plate | None = None + self._flush_pool: ThreadPoolExecutor | None = None def _get_scale_metadata(self, metadata_store: os.PathLike | None) -> None: """Read scale metadata from an existing zarr store. @@ -169,6 +288,11 @@ def on_predict_start(self, trainer: Trainer, pl_module: LightningModule) -> None pl_module : LightningModule The Lightning module being used for prediction. """ + if trainer.world_size > 1: + raise NotImplementedError( + f"HCSPredictionWriter tracks completion per process and appends channels without " + f"cross-rank coordination; run predict on a single device (got world_size={trainer.world_size})." + ) dm: HCSDataModule = trainer.datamodule self._get_scale_metadata(dm.data_path) self.z_padding = dm.z_window_size // 2 if dm.target_2d else 0 @@ -176,16 +300,68 @@ def on_predict_start(self, trainer: Trainer, pl_module: LightningModule) -> None source_channel = dm.source_channel target_channel = dm.target_channel prediction_channel = [ch + "_prediction" for ch in target_channel] - if os.path.exists(self.output_store): + self._prediction_channels = prediction_channel + if ( + self.checkpoint_path is not None + and checkpoint_signature(self.checkpoint_path) != self._checkpoint_signature + ): + raise RuntimeError( + f"Checkpoint '{self.checkpoint_path}' changed since this writer was constructed alongside the " + "model, so its hash would not name the weights actually loaded. Restart the predict." + ) + # Plane-restricted predict (HCSDataModule.predict_z_planes): only the listed + # planes are predicted, the rest keep the fill value, and the planes are part + # of the run identity so a resume never mixes them with another selection. + self._z_planes = dm.predict_dataset.z_planes + # write_input stores source/target slices beside each window, and a plane selection + # writes single planes that a [first, last] flush would fill in between: both write + # per window. + self._write_once = not self.write_input and self._z_planes is None + self._volumes: dict[tuple[str, int], tuple[torch.Tensor, int, int]] = {} + # Volume writes (and the markers after them) run here, in submission order. + self._flush_pool = ThreadPoolExecutor(max_workers=1, thread_name_prefix="prediction-flush") + self._pending: Future | None = None + # Hashes the checkpoint once; every FOV's marker records this identity. + self._run = prediction_run( + array_key=dm.array_key, + z_window_size=dm.z_window_size, + z_reduction=self.z_reduction, + checkpoint_path=self.checkpoint_path, + settings_sha256_12=self.settings_sha256_12, + z_planes_sha256_12=None if self._z_planes is None else z_planes_sha256_12(self._z_planes), + ) + window_arrays = dm.predict_dataset.window_arrays + self._source_shapes = {f"/{array.path}": tzyx_shape(array) for array in window_arrays} + # Array dimensions grow before writes, so only a successful write of every + # distinct (T, Z-window) establishes completion, including overlapping windows. + # A plane-restricted run marks the windows it skips as written up front. + self._written_windows: dict[str, NDArray[np.bool_]] = {} + for array in window_arrays: + written = np.zeros((array.frames, array.slices - dm.z_window_size + 1), dtype=bool) + if self._z_planes is not None: + written[:] = True + for t, planes in enumerate(self._z_planes[array.path.rsplit("/", 1)[0]]): + written[t, list(planes)] = False + self._written_windows[f"/{array.path}"] = written + run_positions = {array.path.rsplit("/", 1)[0] for array in window_arrays} + existed = os.path.exists(self.output_store) + if existed: if self.write_input: raise FileExistsError("Cannot write input to an existing store. Aborting.") else: self.plate = open_ome_zarr(self.output_store, mode="r+") # Validate all positions before mutating any. - needs_append: list[tuple[Position, list[str]]] = [] - for _, pos in self.plate.positions(): + positions = dict(self.plate.positions()) + needs_append: list[tuple[str, list[str]]] = [] + overwritten: list[str] = [] + mixed: list[str] = [] + oversized: list[str] = [] + foreign: list[str] = [] + channel_orders: set[tuple[str, ...]] = set() + for name, pos in positions.items(): existing = set(pos.channel_names) missing = [ch for ch in prediction_channel if ch not in existing] + channel_orders.add((*pos.channel_names, *missing)) for ch in prediction_channel: if ch in existing and not self.overwrite: self.plate.close() @@ -201,10 +377,67 @@ def on_predict_start(self, trainer: Trainer, pl_module: LightningModule) -> None self.output_store, ) if missing: - needs_append.append((pos, missing)) - for pos, channels in needs_append: + needs_append.append((name, missing)) + if name in run_positions: + overwritten.append(name) + if self._outruns_source(pos, name, dm.array_key): + oversized.append(name) + if self._holds_other_planes(pos, name, prediction_channel): + foreign.append(name) + elif self._cannot_share(pos, prediction_channel): + mixed.append(name) + if oversized: + self.plate.close() + raise ValueError( + f"{len(oversized)} FOVs in '{self.output_store}' hold more timepoints or depth " + f"slices than their source (e.g. {oversized[:3]}); arrays only grow, so the stale " + "planes would survive every rewrite yet the FOVs would be marked complete. " + "Predict into a new output store." + ) + if foreign: + self.plate.close() + raise ValueError( + f"{len(foreign)} FOVs in '{self.output_store}' hold {prediction_channel} that another run " + f"predicted on other planes (e.g. {foreign[:3]}); a plane-restricted predict rewrites only " + "its own planes, so remove that store (or predict into a new one) first." + ) + if mixed: + self.plate.close() + raise ValueError( + f"{len(mixed)} FOVs outside this run already hold {prediction_channel} " + f"in '{self.output_store}' that were predicted before completion markers " + f"existed or with a different checkpoint or settings (e.g. {mixed[:3]}); " + "predict into a new output store instead of mixing them." + ) + if len(channel_orders) > 1: + self.plate.close() + raise ValueError( + f"Positions of '{self.output_store}' would disagree on channel order after " + f"appending {prediction_channel} ({sorted(channel_orders)}); the writer addresses " + "channels by one plate-wide index. Predict into a new output store." + ) + # A started marker names this run as the writer of a channel's voxels. + # Run positions get one for every prediction channel: this run + # replaces their voxels, so an interrupted run must never reuse an + # old completion, and the next resume sees unfinished FOVs, not + # legacy ones. FOVs outside the run (e.g. excluded on resume) keep + # their markers, except for the channels appended below: those hold + # zeros this run allocated, and without a marker a later resume + # could not tell them from data predicted before markers existed. + started = {name: prediction_channel for name in overwritten} + for name, channels in needs_append: + started.setdefault(name, channels) for ch in channels: - pos.append_channel(ch, resize_arrays=True) + positions[name].append_channel(ch, resize_arrays=True) + if needs_append: + # Plate.channel_names is cached from the first position when the + # store is opened; reopen so channel indices and positions created + # later in this run see the appended channel. + self.plate.close() + self.plate = open_ome_zarr(self.output_store, mode="r+") + positions = {name: self.plate[name] for name in started} + for name, channels in started.items(): + mark_started(positions[name], channels, self._run) else: channel_names = prediction_channel if self.write_input: @@ -220,6 +453,15 @@ def on_predict_start(self, trainer: Trainer, pl_module: LightningModule) -> None self.source_index = self._get_channel_indices(source_channel) self.target_index = self._get_channel_indices(target_channel) self.prediction_index = self._get_channel_indices(prediction_channel) + # Read now: once volume writes run on the flush thread, this thread leaves the store alone. + self._store_dtypes: dict[str, torch.dtype] = {} + if existed: + for img_name in self._source_shapes: + try: + array = self.plate[img_name] + except KeyError: + continue # created by this run, in the prediction's dtype + self._store_dtypes[img_name] = torch.from_numpy(np.empty(0, dtype=array.dtype)).dtype def _get_channel_indices(self, channel_names: list[str]) -> list[int]: """Get channel indices from the plate for given channel names. @@ -266,6 +508,8 @@ def write_on_batch_end( Index of the current dataloader. """ _logger.debug(f"Writing batch {batch_idx}.") + if self._pending is not None and self._pending.done(): + self._pending.result() # raise a failed volume write here, not volumes later for sample_index, _ in enumerate(batch["index"][0]): self.write_sample(batch, prediction[sample_index], sample_index) @@ -279,7 +523,35 @@ def on_predict_end(self, trainer: Trainer, pl_module: LightningModule) -> None: pl_module : LightningModule The Lightning module. """ - self.plate.close() + try: + for img_name, t_index in list(self._volumes): + self._flush_volume(img_name, t_index, complete=False) + finally: + # Even when a write failed. + self._close() + if self._pending is not None: + self._pending.result() + + def on_exception(self, trainer: Trainer, pl_module: LightningModule, exception: BaseException) -> None: + """Close the store when predict fails, e.g. on a volume write that failed mid-run. + + Parameters + ---------- + trainer : Trainer + The Lightning trainer instance. + pl_module : LightningModule + The Lightning module. + exception : BaseException + The exception that stopped predict. + """ + self._close() + + def _close(self) -> None: + """Let the last volume write finish, then close the store; safe after a partial setup or a second call.""" + if self._flush_pool is not None: + self._flush_pool.shutdown(wait=True) + if self.plate is not None: + self.plate.close() def write_sample( self, @@ -299,15 +571,29 @@ def write_sample( Index of this sample within the batch. """ _logger.debug(f"Writing sample {sample_index}.") - sample_prediction = to_numpy(sample_prediction) img_name, t_index, z_index = [batch["index"][i][sample_index] for i in range(3)] t_index = int(t_index) z_index = int(z_index) + window_z_index = z_index # account for lost slices in 2.5D z_index += self.z_padding z_slice = slice(z_index, z_index + sample_prediction.shape[-3]) - image = self._create_image(img_name, sample_prediction.shape, sample_prediction.dtype) - _resize_image(image, t_index, z_slice) + written = self._written_windows[img_name] + if written[t_index, window_z_index]: + # A repeat would blend into a volume already flushed (a zero buffer) or blend twice. + raise RuntimeError(f"Window z={window_z_index} of {img_name} t={t_index} arrived twice.") + # Blend reads and the write go to the in-memory volume, or to the store per window. + if self._write_once: + # The volume stays on the prediction's device and reaches the host once, at its flush. + sample_prediction = sample_prediction.detach() + if sample_prediction.dtype == torch.bfloat16: + sample_prediction = sample_prediction.float() # to_numpy's cast + dest, lead = self._buffer_volume(img_name, t_index, sample_prediction, z_slice), (slice(None),) + else: + sample_prediction = to_numpy(sample_prediction) + image = self._create_image(img_name, sample_prediction.shape, sample_prediction.dtype) + _resize_image(image, t_index, z_slice) + dest, lead = image.oindex, (t_index, self.prediction_index) if self.write_input: source_stack = batch["source"][sample_index].cpu() center_slice_index = source_stack.shape[-3] // 2 @@ -316,9 +602,172 @@ def write_sample( image[t_index, self.target_index, z_index] = batch["target"][sample_index][:, center_slice_index].cpu() # write CZYX if self.z_padding == 0 and sample_prediction.shape[-3] > 1: - old_stack = image.oindex[t_index, self.prediction_index, z_slice] - sample_prediction = _blend_in(old_stack, sample_prediction, z_slice) - image.oindex[t_index, self.prediction_index, z_slice] = sample_prediction + if self.z_reduction == "blend": + old_stack = dest[(*lead, z_slice)] + if self._write_once and z_slice.start != 0: + # The numpy blend promotes to float64 (integer factors); so does this one. + # The first window is stored as predicted, so it needs no float64 copies. + old_stack, sample_prediction = old_stack.double(), sample_prediction.double() + sample_prediction = _blend_in(old_stack, sample_prediction, z_slice) + else: + # Drop the planes before this window's center: the window centered on + # each of them writes it later and wins. The first window keeps all of + # them because nothing is centered on the leading planes. + keep = 0 if z_index == 0 else sample_prediction.shape[-3] // 2 + sample_prediction = sample_prediction[..., keep:, :, :] + z_slice = slice(z_slice.start + keep, z_slice.stop) + # The buffer has the store's dtype, so this casts like the zarr write and blending + # reads back what the store would hold. + if self._write_once: + _store_into(dest, z_slice, sample_prediction) + else: + dest[(*lead, z_slice)] = sample_prediction + written[t_index, window_z_index] = True + if self._write_once: + if written[t_index].all(): + self._flush_volume(img_name, t_index, complete=written.all()) + elif written.all(): + self._mark_complete(img_name) + + def _mark_complete(self, img_name: str) -> None: + """Write the completion marker of the FOV holding ``img_name``; every window is in the store.""" + name = img_name.strip("/").rsplit("/", 1)[0] + position = self.plate[name] + planes = None if self._z_planes is None else self._z_planes[name] + record_z_planes(position, self._prediction_channels, planes) + marker = completion_marker(self._source_shapes[img_name], self._run) + mark_complete(position, self._prediction_channels, marker) + + def _buffer_volume( + self, img_name: str, t_index: int, sample_prediction: torch.Tensor, z_slice: slice + ) -> torch.Tensor: + """Return the in-memory CZYX volume of ``(img_name, t_index)``, allocating it on first use. + + Parameters + ---------- + img_name : str + Hierarchical path name of the source image. + t_index : int + Timepoint of the volume. + sample_prediction : torch.Tensor + First window of the volume; sets channel count, YX shape, device, and the dtype + unless the store already holds this array (then its dtype, as the per-window + writes would cast to it). + z_slice : slice + Planes of the incoming window. The flush writes from the first plane any + window reached to the last, so planes no window predicts (``target_2d`` + padding, unselected planes) keep what the store holds, as with per-window + writes. + + Returns + ------- + torch.Tensor + Zero-filled ``(C, Z, Y, X)`` buffer spanning the source depth, like a new zarr array. + """ + key = (img_name, t_index) + if key not in self._volumes: + depth = self._source_shapes[img_name][1] + shape = (sample_prediction.shape[0], depth, *sample_prediction.shape[-2:]) + dtype = self._store_dtypes.get(img_name, sample_prediction.dtype) + volume = torch.zeros(shape, dtype=dtype, device=sample_prediction.device) + self._volumes[key] = (volume, z_slice.start, z_slice.stop) + volume, start, stop = self._volumes[key] + if z_slice.stop > volume.shape[1]: + # A prediction deeper than its window: grow like the per-window resize does. + extra = volume.new_zeros((volume.shape[0], z_slice.stop - volume.shape[1], *volume.shape[2:])) + volume = torch.cat([volume, extra], dim=1) + self._volumes[key] = (volume, min(start, z_slice.start), max(stop, z_slice.stop)) + return volume + + def _flush_volume(self, img_name: str, t_index: int, complete: bool) -> None: + """Copy one buffered volume to the host and queue its write, over the planes its windows reached. + + Parameters + ---------- + img_name : str + Hierarchical path name of the source image. + t_index : int + Timepoint of the volume. + complete : bool + The volume is the FOV's last: mark the FOV complete once it is written. + """ + volume, start, stop = self._volumes.pop((img_name, t_index)) + planes = volume[:, start:stop].cpu().numpy() + if self._pending is not None: + # One write in flight bounds the host copies held to two volumes. + self._pending.result() + self._pending = self._flush_pool.submit(self._write_volume, img_name, t_index, planes, start, complete) + + def _write_volume(self, img_name: str, t_index: int, planes: NDArray, start: int, complete: bool) -> None: + """Write planes ``start:`` of one volume to the store, then the FOV's marker if ``complete`` (flush thread).""" + stop = start + planes.shape[1] + image = self._create_image(img_name, (planes.shape[0], stop, *planes.shape[2:]), planes.dtype) + _resize_image(image, t_index, slice(start, stop)) + image.oindex[t_index, self.prediction_index, slice(start, stop)] = planes + if complete: + self._mark_complete(img_name) + + def _outruns_source(self, position: Position, name: str, array_key: str) -> bool: + """Return whether the existing output array outruns this run's source in T or Z. + + Parameters + ---------- + position : Position + Existing output position that this run rewrites. + name : str + Plate-relative position name. + array_key : str + Array level this run writes. + + Returns + ------- + bool + True when the array exists and :func:`outruns` the source. + """ + try: + output = position[array_key] + except KeyError: + return False + return outruns(output, self._source_shapes[f"/{name}/{array_key}"]) + + def _cannot_share(self, position: Position, channels: list[str]) -> bool: + """Return whether ``position`` holds any of ``channels`` that this run cannot vouch for. + + Parameters + ---------- + position : Position + Existing output position outside this run. + channels : list of str + This run's prediction channels. + + Returns + ------- + bool + True when a channel present in the position has no marker of its + own (written before markers existed, so unverifiable even if other + channels are marked), or a marker written with other weights or + settings, or in a layout this version cannot read. + """ + completed = position.zattrs.get(PREDICTION_COMPLETE_KEY, {}) + return any( + channel in position.channel_names and not same_run(completed.get(channel), self._run) + for channel in channels + ) + + def _holds_other_planes(self, position: Position, name: str, channels: list[str]) -> bool: + """Return whether a plane-restricted run would leave another run's planes in ``position``. + + Overwrite rewrites in place and this run writes only its own planes, so a + channel another run wrote survives off them unless that run predicted exactly + these planes (e.g. the same slab with a new checkpoint). A full-volume run + rewrites every plane and never holds any. + """ + if self._z_planes is None or not self._cannot_share(position, channels): + return False + planes = canonical_z_planes(self._z_planes[name]) + return any( + predicted_z_planes(position, channel) != planes for channel in channels if channel in position.channel_names + ) def _create_image(self, img_name: str, shape: tuple[int, ...], dtype: DTypeLike): """Create or retrieve an image in the zarr store. @@ -351,7 +800,15 @@ def _create_image(self, img_name: str, shape: tuple[int, ...], dtype: DTypeLike) _logger.debug(f"Creating image '{img_name}'") _, row_name, col_name, pos_name, arr_name = img_name.split("/") position = self.plate.create_position(row_name, col_name, pos_name) + # A started marker from the first write on distinguishes an interrupted FOV + # from one written before completion markers existed. + mark_started(position, self._prediction_channels, self._run) shape = [1] + list(shape) + if self._z_planes is not None: + # Allocate the full source extent: the planes this run skips must still + # exist (at the fill value) so the store aligns plane by plane with its + # source, instead of ending at the last predicted plane. + shape[0], shape[2] = self._source_shapes[img_name][:2] shape[1] = len(position.channel_names) return position.create_zeros( arr_name, diff --git a/packages/viscy-utils/src/viscy_utils/prediction_metadata.py b/packages/viscy-utils/src/viscy_utils/prediction_metadata.py new file mode 100644 index 000000000..f274a17a6 --- /dev/null +++ b/packages/viscy-utils/src/viscy_utils/prediction_metadata.py @@ -0,0 +1,483 @@ +"""Prediction completion metadata shared by writers and submission tools.""" + +import hashlib +import json +import os +from collections.abc import Iterable, Mapping, Sequence +from pathlib import Path +from typing import Any + +from iohub.ngff import ImageArray, Position + +__all__ = [ + "PREDICTED_Z_PLANES_KEY", + "PREDICTION_COMPLETE_KEY", + "checkpoint_sha256_12", + "canonical_z_planes", + "checkpoint_signature", + "completion_marker", + "mark_complete", + "mark_started", + "marker_identity", + "outruns", + "plane_predict_unfinished", + "predicted_z_planes", + "prediction_complete", + "prediction_run", + "record_z_planes", + "same_marker", + "same_run", + "started_marker", + "tzyx_shape", + "z_planes_sha256_12", +] + +# Position attribute mapping each prediction channel to its marker: the run +# identity from ``prediction_run`` while a run is writing the channel +# (``started_marker``), and that identity plus the source TZYX once every +# window was written (``completion_marker``). A channel with no entry of its +# own was never recorded by any run -- written before markers existed -- so +# nothing can vouch for it, even when other channels of the FOV are marked. +PREDICTION_COMPLETE_KEY = "viscy_prediction_complete" + +# Position attribute mapping each prediction channel to the Z planes a plane-restricted +# run (``HCSDataModule.predict_z_planes``) predicted, one list per timepoint. Every other +# plane holds the array's fill value, so a reader must score only these. Absent for a +# channel predicted on every plane; a full run clears a stale entry. +PREDICTED_Z_PLANES_KEY = "viscy_predicted_z_planes" + +# Marker fields kept for provenance only; two markers that differ solely in +# these still describe the same prediction (a checkpoint may be moved). +_PROVENANCE_KEYS = frozenset({"checkpoint_path"}) + + +def tzyx_shape(array: ImageArray) -> list[int]: + """Return the TZYX extent of a 5D OME-Zarr array. + + Parameters + ---------- + array : ImageArray + Array whose ``(T, C, Z, Y, X)`` shape to project. + + Returns + ------- + list of int + ``[T, Z, Y, X]``, the source identity a completion marker records. + """ + return [array.frames, array.slices, array.height, array.width] + + +def outruns(array: ImageArray, source_shape: list[int]) -> bool: + """Return whether an output array holds more frames or depth slices than its source. + + Arrays only grow and no run writes beyond its source's extent, so the + excess would keep stale voxels under a fresh completion marker. + + Parameters + ---------- + array : ImageArray + Existing output array. + source_shape : list of int + TZYX shape of the source, from :func:`tzyx_shape`. + + Returns + ------- + bool + True when ``array`` exceeds the source in T or Z. + """ + return array.frames > source_shape[0] or array.slices > source_shape[1] + + +_SIGNATURE_FIELDS = ("size", "mtime_ns", "ctime_ns", "ino") + + +def checkpoint_signature(path: str | os.PathLike) -> tuple[int, int, int, int]: + """Return the size, ``st_mtime_ns``, ``st_ctime_ns`` and inode of the file at *path*. + + Overwriting a file or replacing it by rename changes at least one of these: + a copy can preserve size and mtime, but the kernel sets ctime itself and a + rename swaps the inode. Equal signatures therefore mean the same bytes for + the hash memo in :func:`checkpoint_sha256_12` and for the writer's check + that a checkpoint did not change between loading its weights and hashing + it. The one blind spot is a same-size, mtime-preserving overwrite within + the same clock tick as the previous change; identity-critical callers hash + the bytes instead (:func:`prediction_run`). + + Parameters + ---------- + path : str or PathLike + Checkpoint file to describe. + + Returns + ------- + tuple of int + ``(size, st_mtime_ns, st_ctime_ns, st_ino)``. + """ + stat = Path(path).stat() + return stat.st_size, stat.st_mtime_ns, stat.st_ctime_ns, stat.st_ino + + +def _sha256_hex(path: Path) -> str: + """Return the full sha256 hex digest of the file at *path*, read in 1 MiB chunks.""" + hasher = hashlib.sha256() + with open(path, "rb") as f: + for chunk in iter(lambda: f.read(1 << 20), b""): + hasher.update(chunk) + return hasher.hexdigest() + + +def checkpoint_sha256_12(path: str | os.PathLike, *, memoize: bool = True) -> str: + """Return the first 12 hex chars of the sha256 of the file at *path*. + + On repeated calls for the same checkpoint, reads the digest from a + ``.sha256`` sidecar file, avoiding a multi-GB re-read. The sidecar + records the :func:`checkpoint_signature` of the file it hashed and is only + trusted when every field still matches exactly: a checkpoint overwritten + or replaced changes at least one of them even when it was copied with a + preserved or older mtime, so the digest never certifies stale weights (a + sidecar that is merely newer than the checkpoint proves nothing). Writes + the sidecar after a fresh hash; silently tolerates read-only parent + directories and NFS flakes by falling back to recompute. + + Parameters + ---------- + path : str or PathLike + Checkpoint file to hash. + memoize : bool, optional + Consult and maintain the sidecar (default). Pass False to hash the + bytes as they are now and leave the checkpoint's directory untouched: + file metadata cannot prove byte equality, so a digest that certifies + which weights a run loaded must come from the bytes themselves. + + Returns + ------- + str + First 12 hex characters of the file's sha256 digest. + """ + ckpt = Path(path) + if not memoize: + return _sha256_hex(ckpt)[:12] + sidecar = ckpt.with_suffix(ckpt.suffix + ".sha256") + signature = dict(zip(_SIGNATURE_FIELDS, checkpoint_signature(ckpt), strict=True)) + try: + recorded = json.loads(sidecar.read_text()) + if ( + isinstance(recorded, dict) + and all(recorded.get(field) == value for field, value in signature.items()) + and isinstance(recorded.get("sha256"), str) + and len(recorded["sha256"]) == 64 + ): + return recorded["sha256"][:12] + except (OSError, ValueError): + pass + digest = _sha256_hex(ckpt) + try: + tmp = sidecar.with_suffix(sidecar.suffix + ".tmp") + tmp.write_text(json.dumps({"sha256": digest, **signature}) + "\n") + tmp.replace(sidecar) + except OSError: + pass + return digest[:12] + + +def canonical_z_planes(per_t: Sequence[Sequence[int]]) -> list[list[int]]: + """Sorted, de-duplicated ``int`` planes of each timepoint, as :func:`record_z_planes` stores them.""" + return [sorted({int(z) for z in planes}) for planes in per_t] + + +def z_planes_sha256_12(z_planes: Mapping[str, Sequence[Sequence[int]]]) -> str: + """Content hash of a plane selection, independent of key order and plane order. + + Parameters + ---------- + z_planes : Mapping[str, Sequence[Sequence[int]]] + Position name to one plane list per timepoint. + + Returns + ------- + str + First 12 hex digits of the SHA-256 of the canonical JSON. + """ + canonical = {name: canonical_z_planes(per_t) for name, per_t in z_planes.items()} + return hashlib.sha256(json.dumps(canonical, sort_keys=True).encode()).hexdigest()[:12] + + +def prediction_run( + *, + array_key: str, + z_window_size: int, + z_reduction: str, + checkpoint_path: str | os.PathLike | None, + settings_sha256_12: str | None = None, + z_planes_sha256_12: str | None = None, +) -> dict[str, Any]: + """Describe what determines a run's voxels: the weights, the depth handling and the other settings. + + Call once per run; the checkpoint's bytes are hashed here, not per FOV, + and never taken from a ``.sha256`` sidecar: the marker certifies + which weights produced the voxels, and a memo keyed on file metadata + cannot prove that a same-size copy did not replace them. + + Parameters + ---------- + array_key : str + Name of the source (and output) array level that is predicted. + z_window_size : int + Depth of the model's input window. + z_reduction : str + How overlapping depth windows are combined by the writer. + checkpoint_path : str or PathLike or None + Checkpoint the model predicts with; ``None`` when the run has none. + settings_sha256_12 : str or None, optional + Hash of the remaining settings that shape the predicted voxels (model + inference arguments, input normalization, precision), computed by the + submitter from the resolved config; ``None`` when the run records none. + z_planes_sha256_12 : str or None, optional + :func:`z_planes_sha256_12` of the planes a plane-restricted run predicts. + ``None`` (every plane) leaves the key out, so a full run's identity is + the one recorded before plane selection existed. + + Returns + ------- + dict + JSON-serializable identity, including ``checkpoint_sha256_12`` of the + file's content and its path for provenance. + """ + run = { + "array_key": array_key, + "z_window_size": int(z_window_size), + "z_reduction": z_reduction, + "checkpoint_path": None if checkpoint_path is None else str(checkpoint_path), + "checkpoint_sha256_12": None + if checkpoint_path is None + else checkpoint_sha256_12(checkpoint_path, memoize=False), + "settings_sha256_12": settings_sha256_12, + } + if z_planes_sha256_12 is not None: + run["z_planes_sha256_12"] = z_planes_sha256_12 + return run + + +def started_marker(run: dict[str, Any]) -> dict[str, Any]: + """Return the marker a run records while it is writing a channel: its identity alone. + + Parameters + ---------- + run : dict + Run identity from :func:`prediction_run`. + + Returns + ------- + dict + ``dict(run)``; :func:`completion_marker` adds ``source_shape`` once the + channel is fully written. + """ + return dict(run) + + +def completion_marker(source_shape: list[int], run: dict[str, Any]) -> dict[str, Any]: + """Return the marker a run records for a channel predicted from ``source_shape``. + + Parameters + ---------- + source_shape : list of int + TZYX shape of the source array, from :func:`tzyx_shape`. + run : dict + Run identity from :func:`prediction_run`. + + Returns + ------- + dict + ``{"source_shape": [T, Z, Y, X], **run}``. + """ + return {"source_shape": list(source_shape), **run} + + +def marker_identity(marker: Any) -> Any: + """Strip provenance-only fields so markers compare on what was predicted. + + Parameters + ---------- + marker : Any + Recorded marker value, or None when the channel has no entry. + + Returns + ------- + Any + ``marker`` without its provenance-only keys when it is a dict, else + ``marker`` unchanged. + """ + if isinstance(marker, dict): + return {key: value for key, value in marker.items() if key not in _PROVENANCE_KEYS} + return marker + + +def same_marker(recorded: Any, marker: Any) -> bool: + """Return whether a recorded marker equals ``marker`` up to provenance fields. + + Parameters + ---------- + recorded : Any + Recorded marker value, or None when the channel has no entry. + marker : Any + Marker from :func:`started_marker` or :func:`completion_marker`. + + Returns + ------- + bool + True when both describe the same prediction state. + """ + return marker_identity(recorded) == marker_identity(marker) + + +def same_run(marker: Any, run: dict[str, Any]) -> bool: + """Return whether a recorded marker came from ``run``, started or complete, whatever its source shape. + + Parameters + ---------- + marker : Any + Recorded marker value; markers from other layouts never match. + run : dict + Run identity from :func:`prediction_run`. + + Returns + ------- + bool + True when the marker's run fields equal ``run`` up to provenance. + """ + if not isinstance(marker, dict): + return False + recorded = {key: value for key, value in marker.items() if key != "source_shape"} + return marker_identity(recorded) == marker_identity(run) + + +def mark_complete(position: Position, channels: Iterable[str], marker: dict[str, Any]) -> None: + """Record ``marker`` as the completion of ``channels``, keeping other channels' markers. + + Parameters + ---------- + position : Position + Output position whose completion attribute to update. + channels : iterable of str + Prediction channels that were fully written. + marker : dict + Marker from :func:`completion_marker`. + """ + completed = dict(position.zattrs.get(PREDICTION_COMPLETE_KEY, {})) + for channel in channels: + completed[channel] = marker + position.zattrs[PREDICTION_COMPLETE_KEY] = completed + + +def mark_started(position: Position, channels: Iterable[str], run: dict[str, Any]) -> None: + """Record that ``run`` is writing ``channels``, keeping other channels' markers. + + Replaces any completion of ``channels``, whose voxels are about to change, + so an interrupted run never leaves an old completion behind; unlike a + channel with no entry, a started channel is known to be this run's + unfinished work rather than an unverifiable legacy prediction. + + Parameters + ---------- + position : Position + Output position whose completion attribute to update. + channels : iterable of str + Prediction channels about to be (re)written. + run : dict + Run identity from :func:`prediction_run`. + """ + completed = dict(position.zattrs.get(PREDICTION_COMPLETE_KEY, {})) + for channel in channels: + completed[channel] = started_marker(run) + position.zattrs[PREDICTION_COMPLETE_KEY] = completed + + +def prediction_complete(position: Position, channels: Iterable[str], marker: dict[str, Any]) -> bool: + """Return whether every channel of ``position`` was completed with ``marker``. + + Parameters + ---------- + position : Position + Output position to inspect. + channels : iterable of str + Prediction channels that must all be complete. + marker : dict + Marker the current run would record; see :func:`completion_marker`. + + Returns + ------- + bool + True only when each channel's recorded marker equals ``marker`` up to + provenance fields. + """ + completed = position.zattrs.get(PREDICTION_COMPLETE_KEY, {}) + return all(same_marker(completed.get(channel), marker) for channel in channels) + + +def record_z_planes(position: Position, channels: Iterable[str], planes: Sequence[Sequence[int]] | None) -> None: + """Record the planes ``channels`` were predicted on, or clear them for a full prediction. + + Parameters + ---------- + position : Position + Output position whose attribute to update. + channels : iterable of str + Prediction channels that were just fully written. + planes : Sequence[Sequence[int]] or None + One plane list per timepoint, or ``None`` when every plane was predicted. + """ + recorded = dict(position.zattrs.get(PREDICTED_Z_PLANES_KEY, {})) + for channel in channels: + if planes is None: + recorded.pop(channel, None) + else: + recorded[channel] = canonical_z_planes(planes) + if recorded: + position.zattrs[PREDICTED_Z_PLANES_KEY] = recorded + elif PREDICTED_Z_PLANES_KEY in position.zattrs: + del position.zattrs[PREDICTED_Z_PLANES_KEY] + + +def predicted_z_planes(position: Position, channel: str) -> list[list[int]] | None: + """Planes ``channel`` was predicted on (one list per timepoint), or ``None`` for every plane. + + Parameters + ---------- + position : Position + Prediction position to inspect. + channel : str + Prediction channel name. + + Returns + ------- + list[list[int]] or None + The recorded per-timepoint planes, or ``None`` when the channel holds a + prediction on every plane. + """ + return position.zattrs.get(PREDICTED_Z_PLANES_KEY, {}).get(channel) + + +def plane_predict_unfinished(position: Position, channel: str) -> bool: + """Return whether ``channel`` holds a plane-restricted predict that has not finished. + + Such a run replaces the channel's marker with its started marker (which names the + plane selection, ``z_planes_sha256_12``) before its first write, and + :func:`completion_marker` adds ``source_shape`` only once every plane is written. + Until then the planes may be unwritten or another run's, while + :func:`predicted_z_planes` returns ``None`` (a fresh store) or the previous run's + planes (an interrupted re-predict of the same slab), so neither says "unfinished". + + Parameters + ---------- + position : Position + Prediction position to inspect. + channel : str + Prediction channel name. + + Returns + ------- + bool + True when the channel's marker names a plane selection but no ``source_shape``. + """ + marker = position.zattrs.get(PREDICTION_COMPLETE_KEY, {}).get(channel) + return isinstance(marker, dict) and "z_planes_sha256_12" in marker and "source_shape" not in marker diff --git a/packages/viscy-utils/tests/test_prediction_metadata.py b/packages/viscy-utils/tests/test_prediction_metadata.py new file mode 100644 index 000000000..6046c4ff1 --- /dev/null +++ b/packages/viscy-utils/tests/test_prediction_metadata.py @@ -0,0 +1,202 @@ +"""Tests for the checkpoint content hash shared by prediction writers and caches.""" + +import hashlib +import json +import os +import shutil +import time +from pathlib import Path + +import pytest + +from viscy_utils import prediction_metadata +from viscy_utils.prediction_metadata import checkpoint_sha256_12, prediction_run + + +def test_checkpoint_sha256_12(tmp_path: Path) -> None: + """Returns the first 12 hex chars of sha256; differs for different content.""" + file_a = tmp_path / "a.ckpt" + file_b = tmp_path / "b.ckpt" + file_a.write_bytes(b"model-weights-a") + file_b.write_bytes(b"model-weights-b") + + h_a = checkpoint_sha256_12(file_a) + h_b = checkpoint_sha256_12(file_b) + assert len(h_a) == 12 + assert len(h_b) == 12 + assert h_a != h_b + assert checkpoint_sha256_12(file_a) == h_a # deterministic + + +def test_checkpoint_sha256_12_writes_and_reuses_sidecar(tmp_path: Path, monkeypatch) -> None: + """First call writes ``.sha256`` with the file's size and mtime; second call skips the hash.""" + ckpt = tmp_path / "last.ckpt" + ckpt.write_bytes(b"weights") + h1 = checkpoint_sha256_12(ckpt) + sidecar = tmp_path / "last.ckpt.sha256" + recorded = json.loads(sidecar.read_text()) + assert recorded["sha256"][:12] == h1 + assert len(recorded["sha256"]) == 64 + stat = ckpt.stat() + assert recorded["size"] == stat.st_size + assert recorded["mtime_ns"] == stat.st_mtime_ns + assert recorded["ctime_ns"] == stat.st_ctime_ns + assert recorded["ino"] == stat.st_ino + + calls = {"n": 0} + real_sha256 = hashlib.sha256 + + def tracking_sha256(*args, **kwargs): + calls["n"] += 1 + return real_sha256(*args, **kwargs) + + monkeypatch.setattr(prediction_metadata.hashlib, "sha256", tracking_sha256) + h2 = checkpoint_sha256_12(ckpt) + assert h2 == h1 + assert calls["n"] == 0 + + +def test_checkpoint_sha256_12_recomputes_when_sidecar_older(tmp_path: Path) -> None: + """Newer ckpt mtime invalidates the sidecar and forces a recompute.""" + ckpt = tmp_path / "last.ckpt" + ckpt.write_bytes(b"weights-v1") + h1 = checkpoint_sha256_12(ckpt) + + ckpt.write_bytes(b"weights-v2") + sidecar = tmp_path / "last.ckpt.sha256" + old = sidecar.stat().st_mtime + os.utime(ckpt, (old + 10, old + 10)) + + h2 = checkpoint_sha256_12(ckpt) + assert h2 != h1 + assert json.loads(sidecar.read_text())["sha256"][:12] == h2 + + +def test_checkpoint_sha256_12_recomputes_after_replacement_with_older_mtime(tmp_path: Path) -> None: + """A same-size checkpoint copied in with a preserved, older mtime must not reuse the old digest. + + Only exact size and ``st_mtime_ns`` equality qualifies the sidecar; being + newer than the checkpoint is not evidence the content is unchanged. + """ + ckpt = tmp_path / "last.ckpt" + ckpt.write_bytes(b"weights-v1") + h1 = checkpoint_sha256_12(ckpt) + sidecar = tmp_path / "last.ckpt.sha256" + + ckpt.write_bytes(b"weights-v2") # same size as v1 + older = sidecar.stat().st_mtime - 3600 + os.utime(ckpt, (older, older)) + + h2 = checkpoint_sha256_12(ckpt) + assert h2 == hashlib.sha256(b"weights-v2").hexdigest()[:12] + assert h2 != h1 + + +def test_checkpoint_sha256_12_recomputes_after_replacement_preserving_size_and_mtime(tmp_path: Path) -> None: + """A same-size copy that carries the old mtime along still gets a new ctime, so the sidecar is dropped.""" + ckpt = tmp_path / "last.ckpt" + ckpt.write_bytes(b"weights-v1") + h1 = checkpoint_sha256_12(ckpt) + before = ckpt.stat() + replacement = tmp_path / "replacement.ckpt" + replacement.write_bytes(b"weights-v2") + os.utime(replacement, ns=(before.st_atime_ns, before.st_mtime_ns)) + time.sleep(0.05) # ctime advances per kernel tick, not per write + + shutil.copy2(replacement, ckpt) + + assert ckpt.stat().st_mtime_ns == before.st_mtime_ns + assert ckpt.stat().st_size == before.st_size + h2 = checkpoint_sha256_12(ckpt) + assert h2 == hashlib.sha256(b"weights-v2").hexdigest()[:12] + assert h2 != h1 + + +@pytest.mark.parametrize("content", ["not-a-hex-digest\n", "a" * 64 + "\n", '{"sha256": "abc"}\n']) +def test_checkpoint_sha256_12_ignores_unusable_sidecars(tmp_path: Path, content: str) -> None: + """Corrupt, legacy plain-hex, and incomplete sidecars are treated as missing and recomputed.""" + ckpt = tmp_path / "last.ckpt" + ckpt.write_bytes(b"weights") + sidecar = tmp_path / "last.ckpt.sha256" + sidecar.write_text(content) + + h = checkpoint_sha256_12(ckpt) + assert h == hashlib.sha256(b"weights").hexdigest()[:12] + assert json.loads(sidecar.read_text())["sha256"][:12] == h + + +def test_checkpoint_sha256_12_without_memo_ignores_the_sidecar(tmp_path: Path) -> None: + """``memoize=False`` hashes the bytes: it neither trusts a sidecar that matches the file nor leaves one.""" + ckpt = tmp_path / "model.ckpt" + ckpt.write_bytes(b"weights") + sidecar = tmp_path / "model.ckpt.sha256" + expected = hashlib.sha256(b"weights").hexdigest()[:12] + + assert checkpoint_sha256_12(ckpt, memoize=False) == expected + assert not sidecar.exists() + + stat = ckpt.stat() + forged = json.dumps( + { + "sha256": "0" * 64, + "size": stat.st_size, + "mtime_ns": stat.st_mtime_ns, + "ctime_ns": stat.st_ctime_ns, + "ino": stat.st_ino, + } + ) + sidecar.write_text(forged + "\n") + assert checkpoint_sha256_12(ckpt) == "0" * 12 + assert checkpoint_sha256_12(ckpt, memoize=False) == expected + assert sidecar.read_text() == forged + "\n" + + +def test_prediction_run_hashes_the_checkpoint_bytes_not_a_sidecar(tmp_path: Path) -> None: + """The reviewer's probe: a same-size copy carrying the old mtime, made right after hashing, gets its own digest.""" + ckpt = tmp_path / "model.ckpt" + replacement = tmp_path / "replacement.ckpt" + ckpt.write_bytes(b"weights-a") + replacement.write_bytes(b"weights-b") + before = ckpt.stat() + os.utime(replacement, ns=(before.st_atime_ns, before.st_mtime_ns)) + + def identity() -> dict: + return prediction_run(array_key="0", z_window_size=4, z_reduction="blend", checkpoint_path=ckpt) + + first = identity() + shutil.copy2(replacement, ckpt) + second = identity() + + assert first["checkpoint_sha256_12"] == hashlib.sha256(b"weights-a").hexdigest()[:12] + assert second["checkpoint_sha256_12"] == hashlib.sha256(b"weights-b").hexdigest()[:12] + assert not (tmp_path / "model.ckpt.sha256").exists() + + +def test_checkpoint_sha256_12_read_only_dir(tmp_path: Path) -> None: + """Read-only parent dir does not raise; digest still returned.""" + ckpt_dir = tmp_path / "frozen" + ckpt_dir.mkdir() + ckpt = ckpt_dir / "last.ckpt" + ckpt.write_bytes(b"weights") + os.chmod(ckpt_dir, 0o555) + try: + h = checkpoint_sha256_12(ckpt) + assert len(h) == 12 + assert not (ckpt_dir / "last.ckpt.sha256").exists() + finally: + os.chmod(ckpt_dir, 0o755) + + +def test_marker_identity_strips_only_provenance_fields() -> None: + """A moved checkpoint keeps its identity; any field that shapes the voxels stays in it.""" + run = {"array_key": "0", "checkpoint_path": "/a/model.ckpt", "checkpoint_sha256_12": "abc"} + marker = prediction_metadata.completion_marker([1, 2, 3, 4], run) + assert prediction_metadata.marker_identity(marker) == { + "source_shape": [1, 2, 3, 4], + "array_key": "0", + "checkpoint_sha256_12": "abc", + } + assert prediction_metadata.marker_identity({**marker, "checkpoint_path": "/b/model.ckpt"}) == ( + prediction_metadata.marker_identity(marker) + ) + assert prediction_metadata.marker_identity(None) is None diff --git a/packages/viscy-utils/tests/test_prediction_writer.py b/packages/viscy-utils/tests/test_prediction_writer.py index 82aa56b6e..292a41986 100644 --- a/packages/viscy-utils/tests/test_prediction_writer.py +++ b/packages/viscy-utils/tests/test_prediction_writer.py @@ -1,9 +1,954 @@ """Tests for prediction writer blending utilities.""" +import hashlib +import json +import threading +import time +from types import SimpleNamespace + import numpy as np +import pytest import torch +from iohub import open_ome_zarr +from lightning.pytorch import LightningModule, Trainer + +from viscy_data import HCSDataModule +from viscy_data.sliding_window import SlidingWindowDataset +from viscy_utils.callbacks import prediction_writer +from viscy_utils.callbacks.prediction_writer import HCSPredictionWriter, _blend_in, _store_into, _torch_factors +from viscy_utils.prediction_metadata import ( + PREDICTED_Z_PLANES_KEY, + PREDICTION_COMPLETE_KEY, + completion_marker, + mark_complete, + mark_started, + plane_predict_unfinished, + predicted_z_planes, + prediction_complete, + prediction_run, + record_z_planes, + same_run, + started_marker, + z_planes_sha256_12, +) + +Z_SIZE = 16 +Z_WINDOW = 8 +#: The buffered writer blends on the prediction's device, so its bytes are checked on every device present. +ACCELERATORS = [ + "cpu", + pytest.param("gpu", marks=pytest.mark.skipif(not torch.cuda.is_available(), reason="no CUDA device")), +] + + +class _ZStampModule(LightningModule): + """Predict a per-plane stamp ``10 * z_window_start + offset_in_window``. + + Every plane of the assembled volume then names the forward pass and the + within-window position it came from, so the two ``z_reduction`` modes are + distinguishable from the store alone. + """ + + def forward(self, x: torch.Tensor) -> torch.Tensor: + return x + + def predict_step(self, batch, batch_idx: int, dataloader_idx: int = 0) -> torch.Tensor: + source = batch["source"] + depth = source.shape[-3] + offsets = torch.arange(depth, dtype=torch.float32, device=source.device) + starts = torch.as_tensor([int(z) for z in batch["index"][2]], dtype=torch.float32, device=source.device) + stamp = 10.0 * starts.view(-1, 1) + offsets.view(1, -1) + return stamp.view(-1, 1, depth, 1, 1).expand(-1, 1, depth, *source.shape[-2:]).clone() + + +def _run_predict(tmp_path, z_reduction): + """Predict a synthetic single-position plate and return the written CZYX volume.""" + source_store = tmp_path / f"source_{z_reduction}.zarr" + with open_ome_zarr(source_store, layout="hcs", mode="w-", channel_names=["Phase3D", "Nuclei"]) as plate: + position = plate.create_position("0", "0", "0") + position.create_zeros("0", (1, 2, Z_SIZE, 8, 8), dtype=np.float32) + data_module = HCSDataModule( + data_path=str(source_store), + source_channel=["Phase3D"], + target_channel=["Nuclei"], + z_window_size=Z_WINDOW, + batch_size=1, + num_workers=0, + yx_patch_size=[8, 8], + normalizations=[], + augmentations=[], + ) + output_store = tmp_path / f"prediction_{z_reduction}.zarr" + Trainer( + accelerator="cpu", + logger=False, + enable_progress_bar=False, + callbacks=[HCSPredictionWriter(str(output_store), z_reduction=z_reduction)], + ).predict(_ZStampModule(), datamodule=data_module, return_predictions=False) + with open_ome_zarr(output_store, mode="r") as plate: + return np.asarray(plate["0/0/0"]["0"][0, 0, :, 0, 0]) + + +def test_predict_z_reduction_blend_averages_every_covering_window(tmp_path): + """``blend`` makes each plane the unweighted mean of the windows covering it.""" + written = _run_predict(tmp_path, "blend") + n_windows = Z_SIZE - Z_WINDOW + 1 + expected = [ + np.mean([10 * s + (p - s) for s in range(max(0, p - Z_WINDOW + 1), min(n_windows - 1, p) + 1)]) + for p in range(Z_SIZE) + ] + np.testing.assert_allclose(written, expected, rtol=1e-5) + + +def test_predict_z_reduction_center_takes_one_pass_per_plane(tmp_path): + """``center`` gives each plane the window centered on it, and covers the edges.""" + written = _run_predict(tmp_path, "center") + center = Z_WINDOW // 2 + last = Z_SIZE - Z_WINDOW + expected = [] + for p in range(Z_SIZE): + # Interior planes come from their own window's center; the leading planes + # from window 0 and the trailing ones from the last window, since no + # window is centered on them. + start = min(max(0, p - center), last) + expected.append(10 * start + (p - start)) + np.testing.assert_array_equal(written, expected) + interior = range(center, last + center + 1) + assert all(written[p] % 10 == center for p in interior) + + +def test_completion_marker_layout(tmp_path): + """One position attribute maps each prediction channel to what produced it. + + The launcher's resume check and test fixtures read this literal layout, so a + change here is a contract change, not a refactor. + """ + _run_predict(tmp_path, "blend") + run = prediction_run(array_key="0", z_window_size=Z_WINDOW, z_reduction="blend", checkpoint_path=None) + with open_ome_zarr(tmp_path / "prediction_blend.zarr", mode="r") as plate: + position = plate["0/0/0"] + assert position.zattrs[PREDICTION_COMPLETE_KEY] == { + "Nuclei_prediction": { + "source_shape": [1, Z_SIZE, 8, 8], + "array_key": "0", + "z_window_size": Z_WINDOW, + "z_reduction": "blend", + "checkpoint_path": None, + "checkpoint_sha256_12": None, + "settings_sha256_12": None, + } + } + assert prediction_complete(position, ["Nuclei_prediction"], completion_marker([1, Z_SIZE, 8, 8], run)) + assert not prediction_complete(position, ["Nuclei_prediction"], completion_marker([2, Z_SIZE, 8, 8], run)) + + +def test_completion_helpers_keep_other_channels(tmp_path): + """Completing or restarting one channel must leave the other channels' markers intact.""" + run = prediction_run(array_key="0", z_window_size=1, z_reduction="blend", checkpoint_path=None) + marker = completion_marker([1, 2, 3, 4], run) + with open_ome_zarr(tmp_path / "plate.zarr", layout="hcs", mode="w-", channel_names=["A", "B"]) as plate: + position = plate.create_position("0", "0", "0") + mark_complete(position, ["A"], marker) + mark_complete(position, ["B"], marker) + mark_started(position, ["A"], run) + assert position.zattrs[PREDICTION_COMPLETE_KEY] == {"A": started_marker(run), "B": marker} + assert prediction_complete(position, ["B"], marker) + assert not prediction_complete(position, ["A", "B"], marker) + + +class _WindowFunctionModule(LightningModule): + """Predict a nonlinear function of each window's input and position, so blending and window order matter. + + ``center_plane`` returns only the window's center plane (a 2D model, ``target_2d``); ``dtype`` sets the + prediction dtype. + """ + + def __init__(self, center_plane: bool = False, dtype: torch.dtype = torch.float32) -> None: + super().__init__() + self.center_plane = center_plane + self.out_dtype = dtype + + def predict_step(self, batch, batch_idx: int, dataloader_idx: int = 0) -> torch.Tensor: + source = batch["source"] + offsets = torch.arange(source.shape[-3], dtype=source.dtype, device=source.device).view(1, 1, -1, 1, 1) + starts = torch.as_tensor([int(z) for z in batch["index"][2]], dtype=source.dtype, device=source.device) + out = torch.sin(source * (1.0 + 0.1 * offsets)) + 0.01 * starts.view(-1, 1, 1, 1, 1) + if self.center_plane: + mid = out.shape[-3] // 2 + out = out[:, :, mid : mid + 1] + return out.to(self.out_dtype) + + +class _PerWindowWriter(HCSPredictionWriter): + """Reference: the per-window zarr read-modify-write (the ``write_input`` path) in every mode.""" + + def on_predict_start(self, trainer: Trainer, pl_module: LightningModule) -> None: + super().on_predict_start(trainer, pl_module) + self._write_once = False + + +#: Per-timepoint planes of the two FOVs of ``_write_random_source``. +RANDOM_SOURCE_PLANES = {"0/0/0": [[0, 1, 2], [4, 5, 6]], "0/0/1": [[8, 9, 10], [3, 4, 5]]} + + +def _write_random_source(path) -> None: + """Two FOVs of random ``(2, 2, 11, 8, 8)`` float32 Phase3D/Nuclei.""" + rng = np.random.default_rng(0) + with open_ome_zarr(path, layout="hcs", mode="w-", channel_names=["Phase3D", "Nuclei"]) as plate: + for fov in RANDOM_SOURCE_PLANES: + plate.create_position(*fov.split("/")).create_image( + "0", rng.normal(size=(2, 2, 11, 8, 8)).astype(np.float32) + ) + + +def _read_store(path) -> dict: + with open_ome_zarr(path, mode="r") as plate: + return {name: (np.asarray(pos["0"]), pos["0"].chunks, dict(pos.zattrs)) for name, pos in plate.positions()} + + +def _assert_same_bytes(reference: dict, buffered: dict) -> None: + assert buffered.keys() == reference.keys() + for name, (voxels, chunks, attrs) in reference.items(): + new_voxels, new_chunks, new_attrs = buffered[name] + assert (new_voxels.shape, new_voxels.dtype, new_chunks) == (voxels.shape, voxels.dtype, chunks) + assert new_voxels.tobytes() == voxels.tobytes() + assert new_attrs == attrs + + +@pytest.mark.parametrize("accelerator", ACCELERATORS) +@pytest.mark.parametrize("mode", ["blend", "center", "target_2d", "z_planes"]) +@pytest.mark.parametrize("batch_size", [1, 3]) +@pytest.mark.parametrize("limit_batches", [None, 5]) +def test_buffered_volumes_store_the_same_bytes_as_per_window_writes( + tmp_path, accelerator, mode, batch_size, limit_batches +): + """Assembling each volume in memory and writing it once stores the bytes and markers per-window writes store. + + Covers 3D windows (blend, center) and a 2D model's padded center plane (``target_2d``); a plane selection + takes the per-window path on both sides. The buffered volume lives on the prediction's device, so on a GPU + the float64 blend runs there against the reference's numpy blend. + ``limit_batches=5`` stops inside a volume, so the partial volume flushed at predict end is compared too. The + reference reads per window too (``num_workers=1`` disables the volume cache). + """ + source = tmp_path / "source.zarr" + _write_random_source(source) + planes_file = None + if mode == "z_planes": + planes_file = tmp_path / "planes.json" + planes_file.write_text(json.dumps({"positions": RANDOM_SOURCE_PLANES})) + stores = {} + for writer_cls in (_PerWindowWriter, HCSPredictionWriter): + data_module = HCSDataModule( + data_path=str(source), + source_channel=["Phase3D"], + target_channel=["Nuclei"], + z_window_size=1 if mode == "z_planes" else 4, + target_2d=mode == "target_2d", + batch_size=batch_size, + num_workers=1 if writer_cls is _PerWindowWriter else 0, + yx_patch_size=[8, 8], + normalizations=[], + augmentations=[], + predict_z_planes=planes_file, + ) + output = tmp_path / f"pred_{writer_cls.__name__}.zarr" + writer = writer_cls(str(output), z_reduction="center" if mode == "center" else "blend") + Trainer( + accelerator=accelerator, + devices=1, + logger=False, + enable_progress_bar=False, + limit_predict_batches=limit_batches, + callbacks=[writer], + ).predict( + _WindowFunctionModule(center_plane=mode == "target_2d"), datamodule=data_module, return_predictions=False + ) + assert writer._write_once is (writer_cls is HCSPredictionWriter and mode != "z_planes") + assert data_module.predict_dataset.cache_volume is (writer_cls is HCSPredictionWriter and mode != "z_planes") + stores[writer_cls] = _read_store(output) + _assert_same_bytes(stores[_PerWindowWriter], stores[HCSPredictionWriter]) + + +def test_overwrite_keeps_the_planes_a_padded_run_does_not_predict(tmp_path): + """A ``target_2d`` run over a 3D store leaves its padding planes as stored, as per-window writes do.""" + source = tmp_path / "source.zarr" + _write_random_source(source) + + def predict(output, writer, z_window_size: int, target_2d: bool) -> None: + data_module = HCSDataModule( + data_path=str(source), + source_channel=["Phase3D"], + target_channel=["Nuclei"], + z_window_size=z_window_size, + target_2d=target_2d, + batch_size=1, + num_workers=0, + yx_patch_size=[8, 8], + normalizations=[], + augmentations=[], + ) + Trainer(accelerator="cpu", logger=False, enable_progress_bar=False, callbacks=[writer]).predict( + _WindowFunctionModule(center_plane=target_2d), datamodule=data_module, return_predictions=False + ) + + stores = {} + for writer_cls in (_PerWindowWriter, HCSPredictionWriter): + output = tmp_path / f"pred_{writer_cls.__name__}.zarr" + predict(output, HCSPredictionWriter(str(output)), z_window_size=4, target_2d=False) + predict(output, writer_cls(str(output), overwrite=True), z_window_size=5, target_2d=True) + stores[writer_cls] = _read_store(output) + voxels = next(iter(stores[_PerWindowWriter].values()))[0] + assert np.abs(voxels[:, -1, :2]).sum() > 0, "the 3D run's planes below the padding must survive" + _assert_same_bytes(stores[_PerWindowWriter], stores[HCSPredictionWriter]) + + +class _DeeperModule(_WindowFunctionModule): + """Predict one plane more than the window, so the last windows reach past the source depth.""" + + def predict_step(self, batch, batch_idx: int, dataloader_idx: int = 0) -> torch.Tensor: + out = super().predict_step(batch, batch_idx, dataloader_idx) + return torch.cat([out, out[:, :, -1:] + 1.0], dim=2) + + +def test_buffered_volume_grows_for_a_prediction_deeper_than_its_window(tmp_path): + """Planes past the source depth extend the volume, as the per-window resize does.""" + source = tmp_path / "source.zarr" + _write_random_source(source) + stores = {} + for writer_cls in (_PerWindowWriter, HCSPredictionWriter): + output = tmp_path / f"pred_{writer_cls.__name__}.zarr" + data_module = HCSDataModule( + data_path=str(source), + source_channel=["Phase3D"], + target_channel=["Nuclei"], + z_window_size=4, + batch_size=1, + num_workers=0, + yx_patch_size=[8, 8], + normalizations=[], + augmentations=[], + ) + Trainer( + accelerator="cpu", logger=False, enable_progress_bar=False, callbacks=[writer_cls(str(output))] + ).predict(_DeeperModule(), datamodule=data_module, return_predictions=False) + stores[writer_cls] = _read_store(output) + assert {voxels.shape[2] for voxels, _, _ in stores[HCSPredictionWriter].values()} == {12} + _assert_same_bytes(stores[_PerWindowWriter], stores[HCSPredictionWriter]) + + +def test_buffered_volume_takes_the_dtype_of_an_existing_array(tmp_path): + """Overwriting a float32 store with float16 predictions blends in float32, as per-window writes do.""" + source = tmp_path / "source.zarr" + _write_random_source(source) + stores = {} + for writer_cls in (_PerWindowWriter, HCSPredictionWriter): + for dtype, overwrite in ((torch.float32, False), (torch.float16, True)): + output = tmp_path / f"pred_{writer_cls.__name__}.zarr" + data_module = HCSDataModule( + data_path=str(source), + source_channel=["Phase3D"], + target_channel=["Nuclei"], + z_window_size=4, + batch_size=1, + num_workers=0, + yx_patch_size=[8, 8], + normalizations=[], + augmentations=[], + ) + Trainer( + accelerator="cpu", + logger=False, + enable_progress_bar=False, + callbacks=[writer_cls(str(output), overwrite=overwrite)], + ).predict(_WindowFunctionModule(dtype=dtype), datamodule=data_module, return_predictions=False) + stores[writer_cls] = _read_store(output) + assert {voxels.dtype for voxels, _, _ in stores[HCSPredictionWriter].values()} == {np.dtype(np.float32)} + _assert_same_bytes(stores[_PerWindowWriter], stores[HCSPredictionWriter]) + + +@pytest.mark.parametrize("accelerator", ACCELERATORS) +def test_buffered_float16_volume_rounds_the_blend_like_numpy(tmp_path, accelerator): + """A float16 store from float16 predictions rounds each float64 blend to float16 as the numpy write does.""" + source = tmp_path / "source.zarr" + _write_random_source(source) + stores = {} + for writer_cls in (_PerWindowWriter, HCSPredictionWriter): + output = tmp_path / f"pred_{writer_cls.__name__}.zarr" + Trainer( + accelerator=accelerator, + devices=1, + logger=False, + enable_progress_bar=False, + callbacks=[writer_cls(str(output))], + ).predict( + _WindowFunctionModule(dtype=torch.float16), datamodule=_ones_data_module(source), return_predictions=False + ) + stores[writer_cls] = _read_store(output) + assert {voxels.dtype for voxels, _, _ in stores[HCSPredictionWriter].values()} == {np.dtype(np.float16)} + _assert_same_bytes(stores[_PerWindowWriter], stores[HCSPredictionWriter]) + + +def test_store_into_rounds_float64_to_float16_once(): + """Torch rounds float64 to float16 through float32; the volume must hold numpy's single rounding.""" + # Just above the midpoint of 1 and the next float16: float32 rounds it onto the midpoint, then a tie to even. + value = 1 + 2.0**-11 + 2.0**-40 + assert torch.tensor(value, dtype=torch.float64).to(torch.float16).item() == 1.0 + volume = torch.zeros(1, 2, 1, 1, dtype=torch.float16) + _store_into(volume, slice(1, 2), torch.full((1, 1, 1, 1), value, dtype=torch.float64)) + expected = np.float16(value) + assert expected == 1 + 2.0**-10 + assert volume[0, 1, 0, 0].item() == expected + assert volume[0, 0, 0, 0].item() == 0 + + +class _SlowWriter(HCSPredictionWriter): + """Hold every volume write on the flush thread for a while, so a marker that does not wait for it shows.""" + + def _write_volume(self, *args, **kwargs) -> None: + time.sleep(0.2) + super()._write_volume(*args, **kwargs) + + +def test_completion_marker_follows_the_flushed_voxels(tmp_path, monkeypatch): + """A FOV is marked complete only after every one of its volumes is in the store, and the writes run off-thread.""" + source = tmp_path / "source.zarr" + _write_random_source(source) + output = tmp_path / "pred.zarr" + marked = [] + real_mark_complete = prediction_writer.mark_complete + + def checked_mark_complete(position, channels, marker): + # Every voxel of this run is nonzero, so a zero names a volume not yet written. + with open_ome_zarr(output, mode="r") as plate: + voxels = np.asarray(plate[position.zgroup.path]["0"]) + marked.append((position.zgroup.path, voxels.shape, bool((voxels != 0).all()), threading.current_thread())) + real_mark_complete(position, channels, marker) + + monkeypatch.setattr(prediction_writer, "mark_complete", checked_mark_complete) + data_module = _ones_data_module(source, batch_size=3) + Trainer(accelerator="cpu", logger=False, enable_progress_bar=False, callbacks=[_SlowWriter(str(output))]).predict( + _OnesModule(), datamodule=data_module, return_predictions=False + ) + assert [(name, shape, full) for name, shape, full, _ in marked] == [ + (fov, (2, 1, 11, 8, 8), True) for fov in RANDOM_SOURCE_PLANES + ] + assert all(thread is not threading.main_thread() for *_, thread in marked) + + +class _FailingWriter(HCSPredictionWriter): + """Fail the write of one volume on the flush thread.""" + + def __init__(self, *args, fail_volume: int, **kwargs) -> None: + super().__init__(*args, **kwargs) + self.fail_volume = fail_volume + self.n_volumes = 0 + self.closed = False + + def on_predict_start(self, trainer: Trainer, pl_module: LightningModule) -> None: + super().on_predict_start(trainer, pl_module) + close = self.plate.close + + def recording_close() -> None: + self.closed = True + close() + + self.plate.close = recording_close + + def _write_volume(self, *args, **kwargs) -> None: + self.n_volumes += 1 + if self.n_volumes == self.fail_volume: + raise OSError("disk full") + super()._write_volume(*args, **kwargs) + + +@pytest.mark.parametrize("fail_volume", [2, 4]) +def test_a_failed_volume_write_fails_the_predict(tmp_path, fail_volume): + """A write error on the flush thread stops the predict, and its FOV is never marked complete. + + Volume 2 is FOV 0's last: the error stops the run before FOV 1 is written. Volume 4 is FOV 1's last, so the + error surfaces at predict end, after FOV 0 completed. Either way the store is closed. + """ + source = tmp_path / "source.zarr" + _write_random_source(source) + writer = _FailingWriter(str(tmp_path / "pred.zarr"), fail_volume=fail_volume) + with pytest.raises(OSError, match="disk full"): + Trainer(accelerator="cpu", logger=False, enable_progress_bar=False, callbacks=[writer]).predict( + _OnesModule(), datamodule=_ones_data_module(source), return_predictions=False + ) + # Raised mid-run or at predict end, the last write finishes and the store is closed all the same. + assert writer.closed + assert writer._flush_pool._shutdown + with open_ome_zarr(tmp_path / "pred.zarr", mode="r") as plate: + markers = [pos.zattrs[PREDICTION_COMPLETE_KEY]["Nuclei_prediction"] for _, pos in plate.positions()] + assert ["source_shape" in marker for marker in markers] == ([False] if fail_volume == 2 else [True, False]) + + +class _RepeatFirstWindowDataModule(HCSDataModule): + """Serve the first window again after the first volume is done, as a stray retry would.""" + + def predict_dataloader(self): + # FOV 0, t=0 has 8 windows; its first comes back after the volume was flushed. + return torch.utils.data.DataLoader(torch.utils.data.Subset(self.predict_dataset, [*range(8), 0]), batch_size=1) + + +def test_a_window_arriving_twice_is_refused(tmp_path): + """A repeated window would blend into a flushed volume's zero buffer and re-mark the FOV; it must raise.""" + source = tmp_path / "source.zarr" + _write_random_source(source) + data_module = _RepeatFirstWindowDataModule( + data_path=str(source), + source_channel=["Phase3D"], + target_channel=["Nuclei"], + z_window_size=4, + batch_size=1, + num_workers=0, + yx_patch_size=[8, 8], + normalizations=[], + augmentations=[], + ) + with pytest.raises(RuntimeError, match="arrived twice"): + _predict_ones_with(HCSPredictionWriter(str(tmp_path / "pred.zarr")), data_module) + -from viscy_utils.callbacks.prediction_writer import _blend_in +def test_cached_volume_windows_equal_per_window_reads(tmp_path): + """Windows cut from a cached (position, t) volume equal windows read from zarr one by one.""" + source = tmp_path / "source.zarr" + _write_random_source(source) + with open_ome_zarr(source, mode="r") as plate: + positions = [position for _, position in plate.positions()] + datasets = [ + SlidingWindowDataset( + positions=positions, + channels={"source": ["Phase3D", "Nuclei"]}, + z_window_size=4, + load_normalization_metadata=False, + cache_volume=cache_volume, + ) + for cache_volume in (False, True) + ] + assert len(datasets[0]) == len(datasets[1]) == 2 * 2 * 8 + for index in range(len(datasets[0])): + reference, cached = datasets[0][index], datasets[1][index] + assert reference["index"] == cached["index"] + assert torch.equal(reference["source"], cached["source"]) + assert datasets[1]._volume_key is not None + + +class _OnesModule(LightningModule): + def predict_step(self, batch, batch_idx: int, dataloader_idx: int = 0) -> torch.Tensor: + return torch.ones_like(batch["source"]) + + +def _write_source(path, fovs: list[str], z_size: int = 4) -> None: + """Create a two-channel source plate with one ``(1, 2, Z, 8, 8)`` array per FOV.""" + with open_ome_zarr(path, layout="hcs", mode="w-", channel_names=["Phase3D", "Nuclei"]) as plate: + for fov in fovs: + plate.create_position(*fov.split("/")).create_zeros("0", (1, 2, z_size, 8, 8), dtype=np.float32) + + +def _ones_data_module(source, *, exclude=None, target="Nuclei", batch_size=1) -> HCSDataModule: + """Depth-4 windows over every FOV of ``source``, predicting ``target``.""" + return HCSDataModule( + data_path=str(source), + source_channel=["Phase3D"], + target_channel=[target], + z_window_size=4, + batch_size=batch_size, + num_workers=0, + yx_patch_size=[8, 8], + normalizations=[], + augmentations=[], + exclude_fov_names=exclude, + ) + + +def _predict_ones_with(writer: HCSPredictionWriter, data_module: HCSDataModule, *, limit_batches=None) -> None: + """Run ``_OnesModule`` through ``writer`` on the CPU.""" + Trainer( + accelerator="cpu", + logger=False, + enable_progress_bar=False, + limit_predict_batches=limit_batches, + callbacks=[writer], + ).predict(_OnesModule(), datamodule=data_module, return_predictions=False) + + +def _predict_ones( + source, output, *, checkpoint_path=None, exclude=None, overwrite=False, limit_batches=None, target="Nuclei" +) -> None: + """Predict all-ones for every FOV of ``source`` with depth-4 windows into ``output``.""" + writer = HCSPredictionWriter(str(output), overwrite=overwrite, checkpoint_path=checkpoint_path) + _predict_ones_with(writer, _ones_data_module(source, exclude=exclude, target=target), limit_batches=limit_batches) + + +def test_appending_a_channel_keeps_existing_predictions(tmp_path): + """A store holding another model's channel gains ours; its voxels and marker are untouched.""" + source = tmp_path / "source.zarr" + output = tmp_path / "pred.zarr" + _write_source(source, ["0/0/0", "0/0/1"]) + other_run = prediction_run(array_key="0", z_window_size=4, z_reduction="blend", checkpoint_path=None) + with open_ome_zarr(output, layout="hcs", mode="w-", channel_names=["Other_prediction"]) as plate: + for fov in ("0/0/0", "0/0/1"): + position = plate.create_position(*fov.split("/")) + position.create_zeros("0", (1, 1, 4, 8, 8), dtype=np.float32)[:] = 7 + mark_complete(position, ["Other_prediction"], completion_marker([1, 4, 8, 8], other_run)) + + _predict_ones(source, output) + + with open_ome_zarr(output, mode="r") as plate: + assert plate.channel_names == ["Other_prediction", "Nuclei_prediction"] + for fov in ("0/0/0", "0/0/1"): + position = plate[fov] + assert position.channel_names == ["Other_prediction", "Nuclei_prediction"] + np.testing.assert_array_equal(position["0"][:, 0], 7) + np.testing.assert_array_equal(position["0"][:, 1], 1) + marker = position.zattrs[PREDICTION_COMPLETE_KEY] + assert marker["Other_prediction"] == completion_marker([1, 4, 8, 8], other_run) + assert "Nuclei_prediction" in marker + + +def test_writer_refuses_positions_that_would_disagree_on_channel_order(tmp_path): + """Channel indices are plate-wide, so positions must end up with one channel order; check before writing.""" + source = tmp_path / "source.zarr" + output = tmp_path / "pred.zarr" + _write_source(source, ["0/0/0", "0/0/1"]) + with open_ome_zarr(output, layout="hcs", mode="w-", channel_names=["Other_prediction"]) as plate: + for fov in ("0/0/0", "0/0/1"): + plate.create_position(*fov.split("/")).create_zeros("0", (1, 1, 4, 8, 8), dtype=np.float32) + # Separate handles: positions created in one session share one channel list in memory. + for fov, channel in (("0/0/0", "Nuclei_prediction"), ("0/0/1", "Third")): + with open_ome_zarr(output, mode="r+") as plate: + plate[fov].append_channel(channel, resize_arrays=True) + + with pytest.raises(ValueError, match="channel order"): + _predict_ones(source, output, overwrite=True) + + with open_ome_zarr(output, mode="r") as plate: + assert plate["0/0/1"].channel_names == ["Other_prediction", "Third"] + + +def test_interrupted_fov_carries_a_started_marker(tmp_path): + """A FOV the writer created but never finished names the run writing it, unlike pre-marker outputs.""" + source = tmp_path / "source.zarr" + _write_source(source, ["0/0/0"], z_size=8) + _predict_ones(source, tmp_path / "pred.zarr", limit_batches=2) # 2 of 5 depth windows + + run = prediction_run(array_key="0", z_window_size=4, z_reduction="blend", checkpoint_path=None) + with open_ome_zarr(tmp_path / "pred.zarr", mode="r") as plate: + assert plate["0/0/0"].zattrs[PREDICTION_COMPLETE_KEY] == {"Nuclei_prediction": started_marker(run)} + + +def test_writer_refuses_fovs_predicted_before_markers_existed(tmp_path): + """Channels without any completion attribute cannot be verified, so the store is off limits.""" + source = tmp_path / "source.zarr" + output = tmp_path / "pred.zarr" + _write_source(source, ["0/0/0", "0/0/1"]) + with open_ome_zarr(output, layout="hcs", mode="w-", channel_names=["Nuclei_prediction"]) as plate: + for fov in ("0/0/0", "0/0/1"): + plate.create_position(*fov.split("/")).create_zeros("0", (1, 1, 4, 8, 8), dtype=np.float32) + + with pytest.raises(ValueError, match="before completion markers"): + _predict_ones(source, output, exclude=["0/0/0"], overwrite=True) + + with open_ome_zarr(output, mode="r") as plate: + assert all(PREDICTION_COMPLETE_KEY not in pos.zattrs for _, pos in plate.positions()) + np.testing.assert_array_equal(plate["0/0/1/0"][:], 0) + + +def test_writer_refuses_a_legacy_channel_after_another_channel_was_marked(tmp_path): + """Markers are per channel: predicting a new channel into a legacy store vouches for nothing else.""" + source = tmp_path / "source.zarr" + output = tmp_path / "pred.zarr" + _write_source(source, ["0/0/0", "0/0/1"]) + with open_ome_zarr(output, layout="hcs", mode="w-", channel_names=["Nuclei_prediction"]) as plate: + for fov in ("0/0/0", "0/0/1"): + plate.create_position(*fov.split("/")).create_zeros("0", (1, 1, 4, 8, 8), dtype=np.float32)[:] = 999 + _predict_ones(source, output, target="Other") + with open_ome_zarr(output, mode="r") as plate: + assert set(plate["0/0/0"].zattrs[PREDICTION_COMPLETE_KEY]) == {"Other_prediction"} + + with pytest.raises(ValueError, match="before completion markers"): + _predict_ones(source, output, exclude=["0/0/0"], overwrite=True) + + with open_ome_zarr(output, mode="r") as plate: + for fov in ("0/0/0", "0/0/1"): + np.testing.assert_array_equal(plate[fov]["0"][:, 0], 999) + assert set(plate[fov].zattrs[PREDICTION_COMPLETE_KEY]) == {"Other_prediction"} + + +def test_channels_appended_to_excluded_fovs_carry_this_runs_started_marker(tmp_path): + """Appending a channel allocates zeros in every FOV; excluded FOVs record who did, so a resume can finish them.""" + source = tmp_path / "source.zarr" + output = tmp_path / "pred.zarr" + _write_source(source, ["0/0/0", "0/0/1"]) + _predict_ones(source, output) + _predict_ones(source, output, exclude=["0/0/1"], target="Other") + + run = prediction_run(array_key="0", z_window_size=4, z_reduction="blend", checkpoint_path=None) + complete = completion_marker([1, 4, 8, 8], run) + with open_ome_zarr(output, mode="r") as plate: + assert plate["0/0/0"].zattrs[PREDICTION_COMPLETE_KEY] == { + "Nuclei_prediction": complete, + "Other_prediction": complete, + } + assert plate["0/0/1"].zattrs[PREDICTION_COMPLETE_KEY] == { + "Nuclei_prediction": complete, + "Other_prediction": started_marker(run), + } + np.testing.assert_array_equal(plate["0/0/1/0"][:, 1], 0) + + _predict_ones(source, output, exclude=["0/0/0"], target="Other", overwrite=True) + + with open_ome_zarr(output, mode="r") as plate: + for fov in ("0/0/0", "0/0/1"): + assert plate[fov].zattrs[PREDICTION_COMPLETE_KEY] == { + "Nuclei_prediction": complete, + "Other_prediction": complete, + } + np.testing.assert_array_equal(plate[fov]["0"][:], 1) + + +def test_marker_records_the_checkpoint_content(tmp_path): + """The marker names the checkpoint and hashes its content, so a moved copy still matches.""" + source = tmp_path / "source.zarr" + _write_source(source, ["0/0/0"]) + ckpt = tmp_path / "a.ckpt" + ckpt.write_bytes(b"weights-a") + _predict_ones(source, tmp_path / "pred.zarr", checkpoint_path=str(ckpt)) + + with open_ome_zarr(tmp_path / "pred.zarr", mode="r") as plate: + marker = plate["0/0/0"].zattrs[PREDICTION_COMPLETE_KEY]["Nuclei_prediction"] + assert marker["checkpoint_path"] == str(ckpt) + assert marker["checkpoint_sha256_12"] == hashlib.sha256(b"weights-a").hexdigest()[:12] + moved = tmp_path / "moved.ckpt" + moved.write_bytes(b"weights-a") + other = tmp_path / "b.ckpt" + other.write_bytes(b"weights-b") + assert same_run(marker, prediction_run(array_key="0", z_window_size=4, z_reduction="blend", checkpoint_path=moved)) + assert not same_run( + marker, prediction_run(array_key="0", z_window_size=4, z_reduction="blend", checkpoint_path=other) + ) + + +def test_writer_refuses_a_checkpoint_replaced_after_construction(tmp_path): + """The hash must name the weights the model loaded, so a file swapped after the writer saw it is refused.""" + source = tmp_path / "source.zarr" + output = tmp_path / "pred.zarr" + _write_source(source, ["0/0/0"]) + ckpt = tmp_path / "a.ckpt" + ckpt.write_bytes(b"weights-a") + writer = HCSPredictionWriter(str(output), checkpoint_path=str(ckpt)) + ckpt.write_bytes(b"weights-bb") + + with pytest.raises(RuntimeError, match="changed since this writer was constructed"): + _predict_ones_with(writer, _ones_data_module(source)) + assert not output.exists() + + +def test_writer_refuses_to_mix_checkpoints_across_fovs(tmp_path): + """FOVs outside the run that other weights completed make the store off limits, before any write.""" + source = tmp_path / "source.zarr" + output = tmp_path / "pred.zarr" + _write_source(source, ["0/0/0", "0/0/1"]) + ckpt_a = tmp_path / "a.ckpt" + ckpt_a.write_bytes(b"weights-a") + ckpt_b = tmp_path / "b.ckpt" + ckpt_b.write_bytes(b"weights-b") + _predict_ones(source, output, checkpoint_path=str(ckpt_a)) + with open_ome_zarr(output, mode="r") as plate: + before = {name: pos.zattrs[PREDICTION_COMPLETE_KEY] for name, pos in plate.positions()} + + with pytest.raises(ValueError, match="different checkpoint"): + _predict_ones(source, output, checkpoint_path=str(ckpt_b), exclude=["0/0/0"], overwrite=True) + + with open_ome_zarr(output, mode="r") as plate: + assert {name: pos.zattrs[PREDICTION_COMPLETE_KEY] for name, pos in plate.positions()} == before + + +def test_writer_refuses_multi_device_predict(tmp_path): + """Per-process completion bitmaps cannot certify a FOV split across ranks; fail before opening the store.""" + writer = HCSPredictionWriter(str(tmp_path / "pred.zarr")) + with pytest.raises(NotImplementedError, match="single device"): + writer.on_predict_start(SimpleNamespace(world_size=2), None) + assert not (tmp_path / "pred.zarr").exists() + + +class _SourcePlusOneModule(LightningModule): + """Predict ``source + 1``, so every written plane names the source plane it came from.""" + + def predict_step(self, batch, batch_idx: int, dataloader_idx: int = 0) -> torch.Tensor: + return batch["source"] + 1.0 + + +#: Per-timepoint planes for two FOVs of a (T=2, Z=7) source; caps and an interior slab. +SLAB_PLANES = {"0/0/0": [[0, 1], [3, 4, 5]], "0/0/1": [[5, 6], [2, 3, 4]]} + + +def _write_stamped_source(path) -> None: + """Two FOVs of ``(2, 2, 7, 8, 8)`` whose Phase3D plane ``(t, z)`` holds ``100 * t + z + 1``.""" + stamp = (100 * np.arange(2)[:, None] + np.arange(7)[None, :] + 1).astype(np.float32) + with open_ome_zarr(path, layout="hcs", mode="w-", channel_names=["Phase3D", "Nuclei"]) as plate: + for fov in SLAB_PLANES: + data = np.zeros((2, 2, 7, 8, 8), np.float32) + data[:, 0] = stamp[:, :, None, None] + plate.create_position(*fov.split("/")).create_image("0", data) + + +def _predict_planes(source, output, planes_file=None, settings=None) -> HCSDataModule: + data_module = HCSDataModule( + data_path=str(source), + source_channel=["Phase3D"], + target_channel=["Nuclei"], + z_window_size=1, + batch_size=2, + num_workers=0, + yx_patch_size=[8, 8], + normalizations=[], + augmentations=[], + predict_z_planes=planes_file, + ) + Trainer( + accelerator="cpu", + logger=False, + enable_progress_bar=False, + callbacks=[HCSPredictionWriter(str(output), overwrite=True, settings_sha256_12=settings)], + ).predict(_SourcePlusOneModule(), datamodule=data_module, return_predictions=False) + return data_module + + +def test_plane_restricted_predict_writes_only_the_listed_planes(tmp_path): + """Listed planes equal a full predict's; the rest stay at the fill value; the store keeps the full extent.""" + source = tmp_path / "source.zarr" + _write_stamped_source(source) + planes_file = tmp_path / "planes.json" + planes_file.write_text(json.dumps({"positions": SLAB_PLANES, "focus_anchor": "test"})) + + full, slab = tmp_path / "full.zarr", tmp_path / "slab.zarr" + _predict_planes(source, full) + data_module = _predict_planes(source, slab, planes_file) + assert len(data_module.predict_dataset) == sum(len(p) for per_t in SLAB_PLANES.values() for p in per_t) + + with open_ome_zarr(full, mode="r") as full_plate, open_ome_zarr(slab, mode="r") as slab_plate: + for fov, per_t in SLAB_PLANES.items(): + full_arr = np.asarray(full_plate[fov]["0"][:, 0]) + slab_arr = np.asarray(slab_plate[fov]["0"][:, 0]) + assert slab_arr.shape == full_arr.shape == (2, 7, 8, 8) + for t, planes in enumerate(per_t): + others = [z for z in range(7) if z not in planes] + np.testing.assert_array_equal(slab_arr[t, planes], full_arr[t, planes]) + assert (slab_arr[t, others] == 0).all() + # Discriminates: the full store holds a prediction on those planes. + assert (full_arr[t, others] > 0).all() + position = slab_plate[fov] + assert predicted_z_planes(position, "Nuclei_prediction") == per_t + marker = position.zattrs[PREDICTION_COMPLETE_KEY]["Nuclei_prediction"] + assert marker["z_planes_sha256_12"] == z_planes_sha256_12(SLAB_PLANES) + assert marker["source_shape"] == [2, 7, 8, 8] + assert PREDICTED_Z_PLANES_KEY not in full_plate[fov].zattrs + assert "z_planes_sha256_12" not in full_plate[fov].zattrs[PREDICTION_COMPLETE_KEY]["Nuclei_prediction"] + + +def test_full_predict_over_a_plane_store_clears_the_recorded_planes(tmp_path): + """Re-predicting every plane into a plane-restricted store drops its plane record.""" + source = tmp_path / "source.zarr" + _write_stamped_source(source) + planes_file = tmp_path / "planes.json" + planes_file.write_text(json.dumps({"positions": SLAB_PLANES})) + output = tmp_path / "pred.zarr" + _predict_planes(source, output, planes_file) + _predict_planes(source, output) + with open_ome_zarr(output, mode="r") as plate: + for fov in SLAB_PLANES: + assert predicted_z_planes(plate[fov], "Nuclei_prediction") is None + assert (np.asarray(plate[fov]["0"][:, 0]) > 0).all() + + +def test_plane_restricted_predict_refuses_a_store_holding_other_planes(tmp_path): + """A slab predict over another run's planes would leave them around the slab; over its own slab it may replace.""" + source = tmp_path / "source.zarr" + _write_stamped_source(source) + planes_file = tmp_path / "planes.json" + planes_file.write_text(json.dumps({"positions": SLAB_PLANES})) + full = tmp_path / "full.zarr" + _predict_planes(source, full) + with pytest.raises(ValueError, match="other planes"): + _predict_planes(source, full, planes_file) + slab = tmp_path / "slab.zarr" + _predict_planes(source, slab, planes_file, settings="aaaaaaaaaaaa") + # The same slab from other weights or settings (e.g. --ckpt best) rewrites every plane it holds. + _predict_planes(source, slab, planes_file, settings="bbbbbbbbbbbb") + other_planes = tmp_path / "other_planes.json" + other_planes.write_text(json.dumps({"positions": {fov: [[2], [6]] for fov in SLAB_PLANES}})) + with pytest.raises(ValueError, match="other planes"): + _predict_planes(source, slab, other_planes, settings="cccccccccccc") + + +def test_an_interrupted_plane_predict_is_unfinished(tmp_path): + """Until a plane run completes its marker has no source_shape, whatever planes are recorded.""" + source = tmp_path / "source.zarr" + _write_stamped_source(source) + planes_file = tmp_path / "planes.json" + planes_file.write_text(json.dumps({"positions": SLAB_PLANES})) + full, slab = tmp_path / "full.zarr", tmp_path / "slab.zarr" + _predict_planes(source, full) + _predict_planes(source, slab, planes_file) + with open_ome_zarr(full, mode="r") as full_plate, open_ome_zarr(slab, mode="r+") as slab_plate: + assert not plane_predict_unfinished(full_plate["0/0/0"], "Nuclei_prediction") + position = slab_plate["0/0/0"] + assert not plane_predict_unfinished(position, "Nuclei_prediction") + marker = position.zattrs[PREDICTION_COMPLETE_KEY]["Nuclei_prediction"] + # An interrupted re-predict of the same slab: started marker, the old planes still recorded. + mark_started(position, ["Nuclei_prediction"], {k: v for k, v in marker.items() if k != "source_shape"}) + assert predicted_z_planes(position, "Nuclei_prediction") == SLAB_PLANES["0/0/0"] + assert plane_predict_unfinished(position, "Nuclei_prediction") + # An interrupted first predict: started marker, no planes yet. + record_z_planes(position, ["Nuclei_prediction"], None) + assert plane_predict_unfinished(position, "Nuclei_prediction") + + +def test_record_z_planes_keeps_other_channels(tmp_path): + with open_ome_zarr(tmp_path / "p.zarr", layout="hcs", mode="w-", channel_names=["A", "B"]) as plate: + position = plate.create_position("0", "0", "0") + record_z_planes(position, ["A", "B"], [[3, 2, 2]]) + record_z_planes(position, ["A"], None) + assert predicted_z_planes(position, "A") is None + assert predicted_z_planes(position, "B") == [[2, 3]] + record_z_planes(position, ["B"], None) + assert PREDICTED_Z_PLANES_KEY not in position.zattrs + + +@pytest.mark.parametrize( + ("planes", "match"), + [ + ({"0/0/0": [[0]]}, "timepoints"), + ({"0/0/0": [[0], [7]], "0/0/1": [[0], [0]]}, "outside"), + ({"0/0/0": [[0], [0]]}, "no entry"), + ], +) +def test_plane_file_must_cover_every_position_and_timepoint(tmp_path, planes, match): + source = tmp_path / "source.zarr" + _write_stamped_source(source) + planes_file = tmp_path / "planes.json" + planes_file.write_text(json.dumps({"positions": planes})) + with pytest.raises((ValueError, KeyError), match=match): + _predict_planes(source, tmp_path / "pred.zarr", planes_file) + + +def test_plane_restriction_needs_single_plane_windows(tmp_path): + source = tmp_path / "source.zarr" + _write_stamped_source(source) + planes_file = tmp_path / "planes.json" + planes_file.write_text(json.dumps({"positions": SLAB_PLANES})) + data_module = _ones_data_module(source) + data_module.predict_z_planes = planes_file + with pytest.raises(ValueError, match="z_window_size=1"): + data_module.setup("predict") + + +def test_writer_rejects_unknown_z_reduction(): + """An unknown reduction fails at construction, not silently mid-predict.""" + with pytest.raises(ValueError, match="z_reduction"): + HCSPredictionWriter("unused.zarr", z_reduction="mean") # type: ignore[arg-type] def test_blend_in_consistency(): @@ -25,6 +970,17 @@ def test_blend_in_consistency(): np.testing.assert_allclose(result_np, result_torch.squeeze(0).numpy(), rtol=1e-5, atol=1e-5) +def test_blend_factors_cached_under_inference_mode_serve_autograd(): + """Factors first cached inside inference mode (predict) still work in a later blend that records gradients.""" + _torch_factors.cache_clear() # an earlier test may have cached these factors outside inference mode + old = torch.ones(1, 2, 5, 8, 8, dtype=torch.float64) + with torch.inference_mode(): + _blend_in(old, old, slice(3, 8)) + new = torch.zeros(1, 2, 5, 8, 8, dtype=torch.float64, requires_grad=True) + _blend_in(old, new, slice(3, 8)).sum().backward() + assert new.grad is not None + + def test_blend_in_zero_start(): """Verify _blend_in returns new_stack unchanged when z_slice starts at 0.""" old = np.ones((2, 5, 8, 8), dtype=np.float32) From 7d60be268e09079fd7e179d9b211ff61d92c8a7e Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:47:55 -0700 Subject: [PATCH 04/72] feat(viscy-utils): guard every fit with checkpoint and health callbacks Port the training guardrails from dynacell-models. VisCyCLI now injects, on every `fit`: - a latest-weights ModelCheckpoint that owns last.ckpt (the monitored checkpoint gets save_last=False), so last.ckpt always means the latest epoch, inheriting the leaf's write cadence; - MonitorHealthCheck, which raises when the monitored metric is non-finite or bit-identical for 10 validation epochs; - OptimizerHealthCheck, which raises after 5 consecutive non-finite losses or on GradScaler collapse. Also adds the opt-in LinearLRCooldown callback and raises the CLI subprocess test timeout to 120 s (it timed out on main). Behavior change: this applies to cytoland, dynaclr and dynacell fits. Source on dynacell-models: 20e54db4, daa74776, bc0f444c, 74fa18a4 (#497), 92693ae6, 2f9ef319 (#528). Co-Authored-By: Claude Opus 5.5 --- .../src/viscy_utils/callbacks/__init__.py | 8 + .../callbacks/linear_lr_cooldown.py | 86 +++++ .../callbacks/linear_lr_cooldown_test.py | 112 +++++++ .../viscy_utils/callbacks/monitor_health.py | 99 ++++++ .../callbacks/monitor_health_test.py | 296 ++++++++++++++++++ .../viscy_utils/callbacks/optimizer_health.py | 159 ++++++++++ .../callbacks/optimizer_health_test.py | 232 ++++++++++++++ packages/viscy-utils/src/viscy_utils/cli.py | 150 +++++++++ packages/viscy-utils/tests/test_cli.py | 4 +- 9 files changed, 1145 insertions(+), 1 deletion(-) create mode 100644 packages/viscy-utils/src/viscy_utils/callbacks/linear_lr_cooldown.py create mode 100644 packages/viscy-utils/src/viscy_utils/callbacks/linear_lr_cooldown_test.py create mode 100644 packages/viscy-utils/src/viscy_utils/callbacks/monitor_health.py create mode 100644 packages/viscy-utils/src/viscy_utils/callbacks/monitor_health_test.py create mode 100644 packages/viscy-utils/src/viscy_utils/callbacks/optimizer_health.py create mode 100644 packages/viscy-utils/src/viscy_utils/callbacks/optimizer_health_test.py diff --git a/packages/viscy-utils/src/viscy_utils/callbacks/__init__.py b/packages/viscy-utils/src/viscy_utils/callbacks/__init__.py index 6e41540e4..aba381445 100644 --- a/packages/viscy-utils/src/viscy_utils/callbacks/__init__.py +++ b/packages/viscy-utils/src/viscy_utils/callbacks/__init__.py @@ -1,11 +1,19 @@ from viscy_utils.callbacks.embedding_snapshot import EmbeddingSnapshotCallback from viscy_utils.callbacks.embedding_writer import EmbeddingWriter +from viscy_utils.callbacks.linear_lr_cooldown import LinearLRCooldown +from viscy_utils.callbacks.monitor_health import MonitorHealthCheck, MonitorHealthError from viscy_utils.callbacks.online_eval import OnlineEvalCallback +from viscy_utils.callbacks.optimizer_health import OptimizerHealthCheck, OptimizerHealthError from viscy_utils.callbacks.prediction_writer import HCSPredictionWriter __all__ = [ "EmbeddingSnapshotCallback", "EmbeddingWriter", + "LinearLRCooldown", + "MonitorHealthCheck", + "MonitorHealthError", "OnlineEvalCallback", + "OptimizerHealthCheck", + "OptimizerHealthError", "HCSPredictionWriter", ] diff --git a/packages/viscy-utils/src/viscy_utils/callbacks/linear_lr_cooldown.py b/packages/viscy-utils/src/viscy_utils/callbacks/linear_lr_cooldown.py new file mode 100644 index 000000000..92ba9641b --- /dev/null +++ b/packages/viscy-utils/src/viscy_utils/callbacks/linear_lr_cooldown.py @@ -0,0 +1,86 @@ +"""Linear learning-rate cooldown over a fixed range of optimizer steps.""" + +from lightning.pytorch import Callback, LightningModule, Trainer +from torch.optim.lr_scheduler import ConstantLR + + +class LinearLRCooldown(Callback): + """Ramp every param group's LR linearly from its initial value to a final fraction. + + Before each training batch, sets ``lr = initial_lr * factor`` with + ``factor`` equal to 1 before ``start_step``, decreasing linearly to + ``final_factor`` at ``end_step``, and ``final_factor`` afterwards. The + factor depends only on ``trainer.global_step``, so the callback holds no + state and a resumed fit continues the ramp where the checkpoint left it. + + Only valid on top of a constant schedule: the module must have exactly one + optimizer whose scheduler is ``ConstantLR`` with ``factor=1`` (the + ``"Constant"`` schedule of + :func:`viscy_utils.optimizers.configure_adamw_scheduler`), which never + changes the LR. Any other scheduler would overwrite or compound the + cooldown. List this callback before ``LearningRateMonitor`` so the logged + LR is the applied one. + + Parameters + ---------- + start_step : int + Global step at which the cooldown begins (factor 1 at this step). + end_step : int + Global step at which the factor reaches ``final_factor``. + final_factor : float, default 0.0 + LR multiplier at and after ``end_step``, in ``[0, 1]``. + """ + + def __init__(self, start_step: int, end_step: int, final_factor: float = 0.0) -> None: + if not 0 <= start_step < end_step: + raise ValueError(f"Need 0 <= start_step < end_step, got start_step={start_step}, end_step={end_step}") + if not 0.0 <= final_factor <= 1.0: + raise ValueError(f"final_factor must be in [0, 1], got {final_factor}") + self.start_step = start_step + self.end_step = end_step + self.final_factor = final_factor + + def factor(self, step: int) -> float: + """Return the LR multiplier for a global step. + + Parameters + ---------- + step : int + Global optimizer step. + + Returns + ------- + float + LR multiplier. + """ + if step <= self.start_step: + return 1.0 + if step >= self.end_step: + return self.final_factor + progress = (step - self.start_step) / (self.end_step - self.start_step) + return 1.0 - (1.0 - self.final_factor) * progress + + def on_fit_start(self, trainer: Trainer, pl_module: LightningModule) -> None: + """Check that the LR is otherwise constant, so the cooldown is the only LR change.""" + if len(trainer.optimizers) != 1: + raise ValueError(f"LinearLRCooldown needs exactly one optimizer, got {len(trainer.optimizers)}") + configs = trainer.lr_scheduler_configs + if len(configs) != 1: + raise ValueError(f"LinearLRCooldown needs exactly one ConstantLR scheduler, got {len(configs)} schedulers") + scheduler = configs[0].scheduler + if not isinstance(scheduler, ConstantLR) or scheduler.factor != 1: + raise ValueError( + "LinearLRCooldown needs the constant schedule (ConstantLR with factor=1, schedule='Constant'); " + f"got {type(scheduler).__name__}, which would overwrite or compound the cooldown" + ) + + def on_train_batch_start(self, trainer: Trainer, pl_module: LightningModule, batch, batch_idx: int) -> None: + """Set each param group's LR for the step about to run.""" + factor = self.factor(trainer.global_step) + for group in trainer.optimizers[0].param_groups: + if "initial_lr" not in group: + raise KeyError( + "LinearLRCooldown needs param_group['initial_lr'], which torch LR schedulers set; " + "the optimizer has no scheduler attached" + ) + group["lr"] = group["initial_lr"] * factor diff --git a/packages/viscy-utils/src/viscy_utils/callbacks/linear_lr_cooldown_test.py b/packages/viscy-utils/src/viscy_utils/callbacks/linear_lr_cooldown_test.py new file mode 100644 index 000000000..eb48565ec --- /dev/null +++ b/packages/viscy-utils/src/viscy_utils/callbacks/linear_lr_cooldown_test.py @@ -0,0 +1,112 @@ +"""Tests for the linear LR cooldown callback. + +Runs a real ``Trainer`` with the shared ``configure_adamw_scheduler`` so the +epoch-interval ``ConstantLR`` steps between epochs exactly as in a Constant- +schedule fit; the module records the LR its optimizer step actually uses. +""" + +import pytest +import torch +from lightning.pytorch import LightningModule, Trainer +from torch.utils.data import DataLoader, TensorDataset + +from viscy_utils.callbacks import LinearLRCooldown +from viscy_utils.optimizers import configure_adamw_scheduler + +LR = 0.1 +START, END, FINAL = 4, 12, 0.25 +MAX_STEPS = 16 + + +class _RecordingModule(LightningModule): + """Tiny regression module that records the LR applied at each global step.""" + + def __init__(self, schedule: str = "Constant") -> None: + super().__init__() + self.layer = torch.nn.Linear(2, 1) + self.schedule = schedule + self.applied_lr: dict[int, float] = {} + + def training_step(self, batch, batch_idx): + self.applied_lr[self.trainer.global_step] = self.trainer.optimizers[0].param_groups[0]["lr"] + x, y = batch + return torch.nn.functional.mse_loss(self.layer(x), y) + + def configure_optimizers(self): + return configure_adamw_scheduler(self, self.layer, LR, self.schedule, warmup_steps=2) + + +def _loader() -> DataLoader: + # 4 batches per epoch, so the ramp crosses several epoch-end scheduler steps. + return DataLoader(TensorDataset(torch.randn(4, 2), torch.randn(4, 1)), batch_size=1) + + +def _trainer(max_steps: int) -> Trainer: + return Trainer( + max_steps=max_steps, + accelerator="cpu", + devices=1, + logger=False, + enable_progress_bar=False, + enable_model_summary=False, + enable_checkpointing=False, + callbacks=[LinearLRCooldown(START, END, FINAL)], + ) + + +def _expected(step: int) -> float: + if step <= START: + return LR + if step >= END: + return LR * FINAL + return LR * (1 - (1 - FINAL) * (step - START) / (END - START)) + + +def test_cooldown_applies_the_linear_ramp(): + """Applied LR is initial_lr up to start, linear to its final fraction at end, constant after.""" + module = _RecordingModule() + _trainer(MAX_STEPS).fit(module, _loader()) + assert sorted(module.applied_lr) == list(range(MAX_STEPS)) + mid = (START + END) // 2 + assert module.applied_lr[START - 1] == pytest.approx(LR) + assert module.applied_lr[START] == pytest.approx(LR) + assert module.applied_lr[mid] == pytest.approx(LR * (1 + FINAL) / 2) + assert module.applied_lr[END] == pytest.approx(LR * FINAL) + assert module.applied_lr[MAX_STEPS - 1] == pytest.approx(LR * FINAL) + for step, lr in module.applied_lr.items(): + assert lr == pytest.approx(_expected(step)), step + + +def test_cooldown_continues_after_resume_from_mid_ramp(tmp_path): + """A fit resumed mid-cooldown continues the ramp from the restored global step.""" + first = _RecordingModule() + resume_step = 7 + trainer = _trainer(resume_step) + trainer.fit(first, _loader()) + ckpt = tmp_path / "mid.ckpt" + trainer.save_checkpoint(ckpt) + + resumed = _RecordingModule() + _trainer(MAX_STEPS).fit(resumed, _loader(), ckpt_path=ckpt) + # The resumed fit starts at the checkpoint's global step, not at 0, and + # the ramp picks up from there rather than restarting. + assert sorted(resumed.applied_lr) == list(range(resume_step, MAX_STEPS)) + for step, lr in resumed.applied_lr.items(): + assert lr == pytest.approx(_expected(step)), step + assert resumed.applied_lr[resume_step] < LR + + +def test_cooldown_rejects_a_stepwise_scheduler(): + """A step-wise scheduler would overwrite the cooldown, so fit refuses to start.""" + with pytest.raises(ValueError, match="ConstantLR"): + _trainer(MAX_STEPS).fit(_RecordingModule(schedule="WarmupCosine"), _loader()) + + +@pytest.mark.parametrize( + ("start", "end", "final"), + [(5, 5, 0.0), (6, 5, 0.0), (-1, 5, 0.0), (0, 5, -0.1), (0, 5, 1.5)], +) +def test_cooldown_rejects_invalid_arguments(start, end, final): + """Out-of-range steps or final_factor raise at construction.""" + with pytest.raises(ValueError): + LinearLRCooldown(start, end, final) diff --git a/packages/viscy-utils/src/viscy_utils/callbacks/monitor_health.py b/packages/viscy-utils/src/viscy_utils/callbacks/monitor_health.py new file mode 100644 index 000000000..66cb77705 --- /dev/null +++ b/packages/viscy-utils/src/viscy_utils/callbacks/monitor_health.py @@ -0,0 +1,99 @@ +"""Fail loud when a checkpoint monitor stops carrying signal. + +``ModelCheckpoint(monitor=..., save_top_k=k)`` only writes a checkpoint while +``save_top_k`` is unfilled or when the monitored metric improves. A monitor that +goes non-finite or freezes therefore *silently* starves checkpointing: the first +``k`` epochs save, and nothing after that — including ``last.ckpt``, which +Lightning writes on the same cadence. A 200-epoch run can complete with +``Trainer.fit stopped: max_epochs=200 reached``, exit code 0, and no weights +newer than epoch ``k``. + +This callback converts that silent waste into an early crash, in keeping with +the repo's prefer-raising philosophy. It observes only ``trainer.callback_metrics`` +and never touches checkpoint selection, so adding it cannot change which +checkpoint a run considers "best". +""" + +from collections import deque + +import torch +from lightning.pytorch import Callback, LightningModule, Trainer + +__all__ = ["MonitorHealthCheck", "MonitorHealthError"] + + +class MonitorHealthError(RuntimeError): + """Raised when a checkpoint monitor is non-finite or frozen.""" + + +class MonitorHealthCheck(Callback): + """Raise when the checkpoint monitor goes non-finite or stops varying. + + Parameters + ---------- + monitor : str + Metric key to watch, matching the ``monitor`` of the run's monitored + ``ModelCheckpoint`` (e.g. ``loss/validate``). + patience : int + Number of consecutive validation epochs that must share one identical + value before the run is declared frozen. Must be >= 2. + check_finite : bool + Raise as soon as the monitored value is NaN or infinite. + + Raises + ------ + MonitorHealthError + When the monitored metric is non-finite, or has been bit-identical for + ``patience`` consecutive validation epochs. + + Notes + ----- + Sanity-check validation is skipped: it runs before training and would + contribute a value from untrained weights. + + A missing monitor key is *not* an error here. Lightning's own + ``ModelCheckpoint`` already raises for that case, and the metric can be + legitimately absent on the first epochs of some schedules. + """ + + def __init__(self, monitor: str = "loss/validate", patience: int = 10, check_finite: bool = True) -> None: + if patience < 2: + raise ValueError(f"patience must be >= 2 to detect a frozen metric, got {patience}") + self.monitor = monitor + self.patience = patience + self.check_finite = check_finite + self._recent: deque[float] = deque(maxlen=patience) + + def on_validation_end(self, trainer: Trainer, pl_module: LightningModule) -> None: + """Inspect metrics after the module's ``on_validation_epoch_end`` logs them.""" + if trainer.sanity_checking: + return + value = trainer.callback_metrics.get(self.monitor) + if value is None: + return + scalar = value.item() if isinstance(value, torch.Tensor) else float(value) + + if self.check_finite and not torch.isfinite(torch.tensor(scalar)): + raise MonitorHealthError( + f"checkpoint monitor {self.monitor!r} is non-finite ({scalar}) at epoch {trainer.current_epoch}. " + "ModelCheckpoint cannot rank a non-finite metric, so no further checkpoint will be written " + "and this run would finish with no usable weights." + ) + + self._recent.append(scalar) + if len(self._recent) == self.patience and len(set(self._recent)) == 1: + raise MonitorHealthError( + f"checkpoint monitor {self.monitor!r} has been identical ({scalar}) for {self.patience} " + f"consecutive validation epochs, through epoch {trainer.current_epoch}. A metric that does not " + "respond to the weights starves ModelCheckpoint: save_top_k fills once and nothing is saved " + "afterwards, so the run would end with no weights newer than the first few epochs. " + "Check that the validation loss actually depends on the model output." + ) + + def state_dict(self) -> dict: + """Persist the recent-value window so a resumed run keeps its history.""" + return {"recent": list(self._recent)} + + def load_state_dict(self, state_dict: dict) -> None: + """Restore the recent-value window from a checkpoint.""" + self._recent = deque(state_dict.get("recent", []), maxlen=self.patience) diff --git a/packages/viscy-utils/src/viscy_utils/callbacks/monitor_health_test.py b/packages/viscy-utils/src/viscy_utils/callbacks/monitor_health_test.py new file mode 100644 index 000000000..2e227114e --- /dev/null +++ b/packages/viscy-utils/src/viscy_utils/callbacks/monitor_health_test.py @@ -0,0 +1,296 @@ +"""Tests for the checkpoint-monitor guardrails. + +Runs a real ``Trainer`` so the interaction with Lightning's ``ModelCheckpoint`` +is exercised, not mocked — the failure this guards against (top-k fills, then +nothing is saved) only appears through the real callback. +""" + +import pytest +import torch +from jsonargparse import Namespace +from lightning.pytorch import LightningModule, Trainer +from lightning.pytorch.callbacks import ModelCheckpoint +from torch.utils.data import DataLoader, TensorDataset + +from viscy_utils.callbacks import MonitorHealthCheck, MonitorHealthError +from viscy_utils.cli import _inject_checkpoint_guardrails + + +class _ValLossModule(LightningModule): + """Minimal module that logs a scripted ``loss/validate`` sequence.""" + + def __init__(self, val_values: list[float]): + super().__init__() + self.val_values = val_values + self.layer = torch.nn.Linear(2, 1) + + def training_step(self, batch, batch_idx): + x, y = batch + return torch.nn.functional.mse_loss(self.layer(x), y) + + def on_validation_epoch_end(self): + # Index defensively: sanity-check validation also fires this hook. + idx = min(self.current_epoch, len(self.val_values) - 1) + self.log("loss/validate", torch.tensor(self.val_values[idx])) + + def validation_step(self, batch, batch_idx): + return None + + def configure_optimizers(self): + return torch.optim.SGD(self.parameters(), lr=0.01) + + +def _loaders() -> tuple[DataLoader, DataLoader]: + ds = TensorDataset(torch.randn(8, 2), torch.randn(8, 1)) + return DataLoader(ds, batch_size=4), DataLoader(ds, batch_size=4) + + +def _run(val_values: list[float], tmp_path, patience: int = 3, max_epochs: int = 8) -> Trainer: + train_dl, val_dl = _loaders() + trainer = Trainer( + max_epochs=max_epochs, + accelerator="cpu", + logger=False, + enable_progress_bar=False, + enable_model_summary=False, + num_sanity_val_steps=0, + callbacks=[MonitorHealthCheck(monitor="loss/validate", patience=patience)], + default_root_dir=tmp_path, + ) + trainer.fit(_ValLossModule(val_values), train_dl, val_dl) + return trainer + + +def test_frozen_monitor_raises(tmp_path): + """A monitor that never changes must raise rather than train silently.""" + with pytest.raises(MonitorHealthError, match="identical"): + _run([1.024275] * 3, tmp_path, patience=3, max_epochs=3) + + +def test_non_finite_monitor_raises(tmp_path): + """A NaN monitor must raise immediately.""" + with pytest.raises(MonitorHealthError, match="non-finite"): + _run([0.9, float("nan")], tmp_path, patience=3, max_epochs=2) + + +def test_improving_monitor_does_not_raise(tmp_path): + """A normally-varying monitor must train to completion untouched.""" + trainer = _run([0.9, 0.8, 0.7, 0.65, 0.6, 0.55, 0.5, 0.45], tmp_path, patience=3) + assert trainer.current_epoch == 8 + health = next(callback for callback in trainer.callbacks if isinstance(callback, MonitorHealthCheck)) + assert health.state_dict()["recent"] == pytest.approx([0.55, 0.5, 0.45]) + + +def test_brief_plateau_below_patience_does_not_raise(tmp_path): + """A plateau shorter than ``patience`` is normal training, not a dead metric.""" + trainer = _run([0.9, 0.8, 0.8, 0.7, 0.7, 0.6, 0.55, 0.5], tmp_path, patience=3) + assert trainer.current_epoch == 8 + + +def test_frozen_monitor_starves_real_model_checkpoint(tmp_path): + """Reproduce the underlying failure: a frozen monitor stops all saving. + + Without the guardrail a constant monitor fills ``save_top_k`` and then writes + nothing more — including ``last.ckpt``. This is the regression the injected + unmonitored checkpoint exists to prevent. + """ + train_dl, val_dl = _loaders() + ckpt_dir = tmp_path / "checkpoints" + monitored = ModelCheckpoint( + dirpath=ckpt_dir, + monitor="loss/validate", + filename="epoch={epoch}-step={step}", + auto_insert_metric_name=False, + every_n_epochs=1, + save_top_k=2, + save_last=True, + ) + trainer = Trainer( + max_epochs=8, + accelerator="cpu", + logger=False, + enable_progress_bar=False, + enable_model_summary=False, + num_sanity_val_steps=0, + callbacks=[monitored], + default_root_dir=tmp_path, + ) + trainer.fit(_ValLossModule([1.024275] * 8), train_dl, val_dl) + + saved = sorted(p.name for p in ckpt_dir.glob("epoch=*.ckpt")) + # save_top_k=2 fills at epochs 0 and 1; the constant metric never improves after. + assert len(saved) == 2, saved + assert saved == ["epoch=0-step=2.ckpt", "epoch=1-step=4.ckpt"], saved + # 8 epochs ran, yet nothing newer than epoch 1 exists. + assert trainer.current_epoch == 8 + + +def test_injection_adds_guardrails_and_preserves_selection(): + """Injection must add the safety net without touching selection semantics.""" + monitored = Namespace( + class_path="lightning.pytorch.callbacks.ModelCheckpoint", + init_args=Namespace( + monitor="loss/validate", + mode="min", + filename="epoch={epoch}-step={step}-loss={loss/validate:.3f}", + save_top_k=5, + every_n_epochs=1, + save_last=True, + dirpath="/models/run/checkpoints", + ), + ) + config = Namespace(fit=Namespace(trainer=Namespace(callbacks=[monitored]))) + _inject_checkpoint_guardrails(config, "fit") + callbacks = config["fit"]["trainer"]["callbacks"] + + assert len(callbacks) == 3 + # Selection semantics of the monitored callback are untouched... + assert monitored["init_args"]["monitor"] == "loss/validate" + assert monitored["init_args"]["mode"] == "min" + assert monitored["init_args"]["save_top_k"] == 5 + assert monitored["init_args"]["filename"] == "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + # ...except that it no longer owns `last.ckpt`. + assert monitored["init_args"]["save_last"] is False + + latest = callbacks[1] + assert latest["class_path"] == "lightning.pytorch.callbacks.ModelCheckpoint" + assert latest["init_args"]["monitor"] is None + assert latest["init_args"]["save_last"] is True + assert latest["init_args"]["save_top_k"] == 1 + assert latest["init_args"]["dirpath"] == "/models/run/checkpoints" + + health = callbacks[2] + assert health["class_path"] == "viscy_utils.callbacks.MonitorHealthCheck" + assert health["init_args"]["monitor"] == "loss/validate" + + +def test_injection_is_idempotent(): + """Re-running injection must not stack duplicate callbacks.""" + monitored = Namespace( + class_path="lightning.pytorch.callbacks.ModelCheckpoint", + init_args=Namespace(monitor="loss/validate", save_top_k=5, save_last=True, dirpath="/d"), + ) + config = Namespace(fit=Namespace(trainer=Namespace(callbacks=[monitored]))) + _inject_checkpoint_guardrails(config, "fit") + _inject_checkpoint_guardrails(config, "fit") + assert len(config["fit"]["trainer"]["callbacks"]) == 3 + + +def test_injection_skips_non_fit_subcommands(): + """predict/test/validate write no checkpoints, so nothing is injected.""" + monitored = Namespace( + class_path="lightning.pytorch.callbacks.ModelCheckpoint", + init_args=Namespace(monitor="loss/validate", save_last=True, dirpath="/d"), + ) + config = Namespace(predict=Namespace(trainer=Namespace(callbacks=[monitored]))) + _inject_checkpoint_guardrails(config, "predict") + assert len(config["predict"]["trainer"]["callbacks"]) == 1 + assert monitored["init_args"]["save_last"] is True + + +def test_injection_noop_without_monitored_checkpoint(): + """A config with no monitored checkpoint gets no health check to attach to.""" + unmonitored = Namespace( + class_path="lightning.pytorch.callbacks.ModelCheckpoint", + init_args=Namespace(monitor=None, save_last=True, dirpath="/d"), + ) + config = Namespace(fit=Namespace(trainer=Namespace(callbacks=[unmonitored]))) + _inject_checkpoint_guardrails(config, "fit") + assert len(config["fit"]["trainer"]["callbacks"]) == 1 + + +def test_patience_below_two_rejected(): + """patience<2 cannot distinguish a frozen metric from a single sample.""" + with pytest.raises(ValueError, match="patience must be >= 2"): + MonitorHealthCheck(patience=1) + + +def test_injection_inherits_the_leaf_write_cadence(): + """The latest-weights callback must not force ``every_n_epochs: 1``. + + A leaf that sets ``every_n_epochs`` is making a deliberate write-amplification + decision. The Phase 17 arms run ~1470 epochs with a 424 MB checkpoint and set + cadence 10 for exactly that reason; forcing 1 here rewrote both ``latest-*`` + and ``last.ckpt`` every epoch (~1.25 TB of NFS traffic per arm) and silently + overrode the leaf. + """ + monitored = Namespace( + class_path="lightning.pytorch.callbacks.ModelCheckpoint", + init_args=Namespace( + monitor="loss/validate", + save_top_k=4, + every_n_epochs=10, + save_last=True, + dirpath="/models/run/checkpoints", + ), + ) + config = Namespace(fit=Namespace(trainer=Namespace(callbacks=[monitored]))) + _inject_checkpoint_guardrails(config, "fit") + + latest = config["fit"]["trainer"]["callbacks"][1] + assert latest["init_args"]["every_n_epochs"] == 10 + # The monitored callback's own cadence is still its own. + assert monitored["init_args"]["every_n_epochs"] == 10 + + +def test_injection_defaults_cadence_to_every_epoch(): + """A leaf that sets no cadence keeps the original every-epoch behaviour.""" + monitored = Namespace( + class_path="lightning.pytorch.callbacks.ModelCheckpoint", + init_args=Namespace(monitor="loss/validate", save_top_k=4, save_last=True, dirpath="/d"), + ) + config = Namespace(fit=Namespace(trainer=Namespace(callbacks=[monitored]))) + _inject_checkpoint_guardrails(config, "fit") + + assert config["fit"]["trainer"]["callbacks"][1]["init_args"]["every_n_epochs"] == 1 + + +def test_inherited_cadence_still_saves_when_monitor_is_frozen(tmp_path): + """End-to-end: cadence 4 writes latest weights without writing every epoch. + + Runs the real Trainer with a frozen monitor, which starves the monitored + callback after ``save_top_k`` fills. The unmonitored callback must still + produce weights from the run's final epochs -- the guardrail's whole purpose -- + while writing 2 times over 8 epochs rather than 8. + """ + train_dl, val_dl = _loaders() + ckpt_dir = tmp_path / "checkpoints" + monitored = Namespace( + class_path="lightning.pytorch.callbacks.ModelCheckpoint", + init_args=Namespace( + monitor="loss/validate", + filename="epoch={epoch}-step={step}", + auto_insert_metric_name=False, + save_top_k=2, + every_n_epochs=4, + save_last=True, + dirpath=str(ckpt_dir), + ), + ) + config = Namespace(fit=Namespace(trainer=Namespace(callbacks=[monitored]))) + _inject_checkpoint_guardrails(config, "fit") + specs = config["fit"]["trainer"]["callbacks"] + + latest_cb = ModelCheckpoint(**{k: v for k, v in specs[1]["init_args"].items()}) + monitored_cb = ModelCheckpoint(**{k: v for k, v in specs[0]["init_args"].items()}) + trainer = Trainer( + max_epochs=8, + accelerator="cpu", + logger=False, + enable_progress_bar=False, + enable_model_summary=False, + num_sanity_val_steps=0, + callbacks=[monitored_cb, latest_cb], + default_root_dir=tmp_path, + ) + trainer.fit(_ValLossModule([1.024275] * 8), train_dl, val_dl) + + # Lightning fires every_n_epochs when (epoch + 1) % n == 0, so this writes at + # epochs 3 and 7 only -- 2 of 8 epochs -- and save_top_k=1 keeps just the last. + latest = sorted(p.name for p in ckpt_dir.glob("latest-*.ckpt")) + assert latest == ["latest-epoch=7-step=16.ckpt"], latest + assert (ckpt_dir / "last.ckpt").is_file() + # The point of the guardrail: weights exist from the END of the run (epoch 7 is + # the last of 8, zero-indexed), not just from where the frozen monitor stopped + # improving -- the monitored callback's top-k filled at epochs 3 and never moved. + assert torch.load(ckpt_dir / "last.ckpt", map_location="cpu", weights_only=False)["epoch"] == 7 diff --git a/packages/viscy-utils/src/viscy_utils/callbacks/optimizer_health.py b/packages/viscy-utils/src/viscy_utils/callbacks/optimizer_health.py new file mode 100644 index 000000000..432e33439 --- /dev/null +++ b/packages/viscy-utils/src/viscy_utils/callbacks/optimizer_health.py @@ -0,0 +1,159 @@ +"""Fail loud when the optimizer stops making progress at the step level. + +Two failure modes hide from every loss-based monitor, and one of them cost 24 +GPU-days of FCMAE-2D fits that ran to ``epoch 199/200`` with the weights still at +their initialization: + +**Under ``16-mixed``, a NaN *gradient* is silent.** ``GradScaler`` inspects the +gradients, skips the optimizer step when any is non-finite, and halves its scale. +The forward pass — and therefore the logged loss — stays perfectly finite. From +``2**16`` it takes ~166 halvings to reach exactly ``0.0``, after which *every* +step is skipped forever: the weights never move again, and the run still exits 0. +The trigger there was a ``sqrt`` at 0 (infinite derivative) inside an SSIM +Cauchy-Schwarz bound, but any NaN-producing backward does the same thing. + +**Under ``bf16-mixed`` there is no scaler at all**, so a NaN gradient instead +lands in the weights and the loss goes non-finite on the next forward. That is +loud in a log, but nothing *stops* the run, so it burns the rest of its wall +allocation. + +This callback covers both: it watches the scaler's scale where there is one, and +the training loss everywhere. It only reads state — it never rescales, skips, or +touches optimization — so enabling it cannot change a healthy run's numerics. + +Related but distinct: :class:`~viscy_utils.callbacks.MonitorHealthCheck` watches +the *checkpoint monitor* once per validation epoch, so it catches the same freeze +only after ``patience`` epochs and cannot say why. This one trips within tens of +steps and names the mechanism. +""" + +from collections.abc import Mapping + +import torch +from lightning.pytorch import Callback, LightningModule, Trainer + +__all__ = ["OptimizerHealthCheck", "OptimizerHealthError"] + + +class OptimizerHealthError(RuntimeError): + """Raised when the optimizer can no longer be making progress.""" + + +class OptimizerHealthCheck(Callback): + """Raise when the AMP scale collapses or the training loss goes non-finite. + + Parameters + ---------- + min_scale : float + Raise once ``GradScaler``'s scale falls below this value. fp16 AMP + normally operates between ``2**10`` and ``2**16``; below ``1.0`` the + scaler is shrinking gradients rather than protecting them, which no + healthy run needs. Ignored when the run has no scaler. + max_consecutive_skips : int + Raise after this many consecutive scale *reductions* with no growth in + between. Each reduction is one skipped optimizer step. A handful during + AMP warmup is normal and expected; a couple of dozen in a row is not. + max_consecutive_nonfinite : int + Raise after this many consecutive training batches whose loss is NaN or + infinite. Small but non-zero so a single transient overflow does not kill + a run. + + Raises + ------ + OptimizerHealthError + When the scale falls below ``min_scale``, when ``max_consecutive_skips`` + steps are skipped in a row, or when the loss is non-finite for + ``max_consecutive_nonfinite`` batches in a row. + + Notes + ----- + Skips are counted only when the scale actually *changes*, so gradient + accumulation — which fires ``on_train_batch_end`` on batches where no + optimizer step happened, leaving the scale flat — cannot reset the counter + and mask a genuine run of skipped steps. + + The loss arm reads the value ``training_step`` returned rather than a logged + metric, so it also covers modules that do not log a training loss. Manual- + optimization modules that return ``None`` (e.g. the GAN engine) are skipped + by the loss arm; their scaler arm still applies. + """ + + def __init__( + self, + min_scale: float = 1.0, + max_consecutive_skips: int = 25, + max_consecutive_nonfinite: int = 5, + ) -> None: + if max_consecutive_skips < 1: + raise ValueError(f"max_consecutive_skips must be >= 1, got {max_consecutive_skips}") + if max_consecutive_nonfinite < 1: + raise ValueError(f"max_consecutive_nonfinite must be >= 1, got {max_consecutive_nonfinite}") + self.min_scale = min_scale + self.max_consecutive_skips = max_consecutive_skips + self.max_consecutive_nonfinite = max_consecutive_nonfinite + self._prev_scale: float | None = None + self._consecutive_skips = 0 + self._consecutive_nonfinite = 0 + + def on_train_batch_end(self, trainer: Trainer, pl_module: LightningModule, outputs, batch, batch_idx: int) -> None: + """Check the batch loss, then the AMP scale, after every training batch.""" + self._check_loss(outputs, trainer) + self._check_scale(trainer) + + def _check_loss(self, outputs, trainer: Trainer) -> None: + """Count consecutive non-finite training losses and raise past the limit.""" + loss = outputs.get("loss") if isinstance(outputs, Mapping) else outputs + if not isinstance(loss, torch.Tensor): + return + if torch.isfinite(loss).all(): + self._consecutive_nonfinite = 0 + return + self._consecutive_nonfinite += 1 + if self._consecutive_nonfinite >= self.max_consecutive_nonfinite: + raise OptimizerHealthError( + f"training loss has been non-finite for {self._consecutive_nonfinite} consecutive batches " + f"(step {trainer.global_step}, last value {loss.detach().float().mean().item()}). Without a " + "GradScaler to skip the step -- bf16-mixed and 32-true have none -- a NaN gradient lands in " + "the weights and every later forward is non-finite, so this run cannot recover." + ) + + def _check_scale(self, trainer: Trainer) -> None: + """Track the ``GradScaler`` scale and raise on collapse or sustained skips.""" + scaler = getattr(trainer.precision_plugin, "scaler", None) + if scaler is None: + return + scale = float(scaler.get_scale()) + prev = self._prev_scale + self._prev_scale = scale + if prev is not None and scale != prev: + # A reduction means GradScaler found a non-finite gradient and skipped + # the step; growth means a run of successful steps cleared the counter. + self._consecutive_skips = self._consecutive_skips + 1 if scale < prev else 0 + + if scale < self.min_scale: + raise OptimizerHealthError( + f"GradScaler scale collapsed to {scale} (floor {self.min_scale}) at step {trainer.global_step}. " + "The scale only halves when a gradient is non-finite, so the backward pass is producing NaN " + "or inf while the forward stays finite. At scale 0 every optimizer step is skipped forever " + "and the weights stay at their last value for the rest of the run." + ) + if self._consecutive_skips >= self.max_consecutive_skips: + raise OptimizerHealthError( + f"GradScaler halved its scale {self._consecutive_skips} times in a row without growing " + f"(now {scale}, step {trainer.global_step}). Every one of those optimizer steps was skipped " + "for a non-finite gradient, so the weights are not moving even though the loss is finite." + ) + + def state_dict(self) -> dict: + """Persist the counters so a resumed run does not restart mid-collapse.""" + return { + "prev_scale": self._prev_scale, + "consecutive_skips": self._consecutive_skips, + "consecutive_nonfinite": self._consecutive_nonfinite, + } + + def load_state_dict(self, state_dict: dict) -> None: + """Restore the counters from a checkpoint.""" + self._prev_scale = state_dict.get("prev_scale") + self._consecutive_skips = state_dict.get("consecutive_skips", 0) + self._consecutive_nonfinite = state_dict.get("consecutive_nonfinite", 0) diff --git a/packages/viscy-utils/src/viscy_utils/callbacks/optimizer_health_test.py b/packages/viscy-utils/src/viscy_utils/callbacks/optimizer_health_test.py new file mode 100644 index 000000000..c5d0a1023 --- /dev/null +++ b/packages/viscy-utils/src/viscy_utils/callbacks/optimizer_health_test.py @@ -0,0 +1,232 @@ +"""Tests for the step-level optimizer guardrail. + +Runs a real ``Trainer`` throughout: the failure being guarded against is produced +by the interaction of a NaN backward with Lightning's precision plugin, so a +mocked scaler would prove nothing. The NaN-gradient module reproduces the actual +mechanism that froze the 24 FCMAE-2D fits — a ``sqrt`` evaluated at exactly 0, +whose derivative is infinite, multiplied by a zero incoming gradient — rather +than asserting on a hand-set scale. +""" + +import pytest +import torch +from jsonargparse import Namespace +from lightning.pytorch import LightningModule, Trainer +from torch.utils.data import DataLoader, TensorDataset + +from viscy_utils.callbacks import OptimizerHealthCheck, OptimizerHealthError +from viscy_utils.cli import _inject_optimizer_health_guard + +_needs_cuda = pytest.mark.skipif( + not torch.cuda.is_available(), + reason="fp16 AMP has no GradScaler on CPU -- Lightning silently downgrades 16-mixed to bf16-mixed", +) + + +class _HealthyModule(LightningModule): + """Ordinary regression module with finite gradients everywhere.""" + + def __init__(self) -> None: + super().__init__() + self.layer = torch.nn.Linear(2, 1) + + def training_step(self, batch, batch_idx): + x, y = batch + return torch.nn.functional.mse_loss(self.layer(x), y) + + def configure_optimizers(self): + return torch.optim.SGD(self.parameters(), lr=0.01) + + +class _NaNGradientModule(_HealthyModule): + """Finite forward, NaN backward — the FCMAE-2D freeze, minimally reproduced. + + ``sqrt`` at 0 has an infinite derivative, and the incoming gradient of the + zeroed product is 0, so autograd evaluates ``0 * inf = nan`` for the whole + term while its forward contribution is exactly 0. The loss therefore stays + finite and only the gradient is poisoned. + """ + + def training_step(self, batch, batch_idx): + x, y = batch + pred = self.layer(x) + bound = torch.sqrt(pred * torch.zeros_like(pred)) + loss = torch.nn.functional.mse_loss(pred, y) + bound.mean() + assert torch.isfinite(loss).all(), "forward must stay finite for this test to mean anything" + return loss + + +class _NaNLossModule(_HealthyModule): + """Loss itself goes non-finite, as it does under bf16 with no scaler.""" + + def training_step(self, batch, batch_idx): + x, y = batch + return torch.nn.functional.mse_loss(self.layer(x), y) * float("nan") + + +def _loader() -> DataLoader: + return DataLoader(TensorDataset(torch.randn(32, 2), torch.randn(32, 1)), batch_size=4) + + +def _run(module: LightningModule, tmp_path, precision: str, accelerator: str, **guard_kwargs) -> Trainer: + trainer = Trainer( + max_epochs=4, + accelerator=accelerator, + devices=1, + precision=precision, + logger=False, + enable_progress_bar=False, + enable_model_summary=False, + enable_checkpointing=False, + num_sanity_val_steps=0, + callbacks=[OptimizerHealthCheck(**guard_kwargs)], + default_root_dir=tmp_path, + ) + trainer.fit(module, _loader()) + return trainer + + +@_needs_cuda +def test_nan_gradient_under_fp16_raises_while_the_loss_stays_finite(tmp_path): + """The silent case: finite loss, skipped steps, scale walking to zero.""" + with pytest.raises(OptimizerHealthError, match="halved its scale|scale collapsed"): + _run( + _NaNGradientModule(), + tmp_path, + precision="16-mixed", + accelerator="gpu", + max_consecutive_skips=3, + ) + + +@_needs_cuda +def test_healthy_fp16_run_completes_untouched(tmp_path): + """A normal fp16 run must not trip the guard, and must actually move weights.""" + module = _HealthyModule() + before = module.layer.weight.detach().clone() + trainer = _run(module, tmp_path, precision="16-mixed", accelerator="gpu", max_consecutive_skips=3) + assert trainer.current_epoch == 4 + assert not torch.allclose(before, module.layer.weight.detach().cpu()) + + +def test_non_finite_loss_raises_without_a_scaler(tmp_path): + """bf16 has no GradScaler, so the loss arm is the only thing that can catch it.""" + with pytest.raises(OptimizerHealthError, match="non-finite for"): + _run( + _NaNLossModule(), + tmp_path, + precision="bf16-mixed", + accelerator="cpu", + max_consecutive_nonfinite=2, + ) + + +def test_healthy_bf16_run_completes_untouched(tmp_path): + """The precision the 2D FCMAE fits actually use must train to completion.""" + module = _HealthyModule() + before = module.layer.weight.detach().clone() + trainer = _run(module, tmp_path, precision="bf16-mixed", accelerator="cpu", max_consecutive_nonfinite=2) + assert trainer.current_epoch == 4 + assert not torch.allclose(before, module.layer.weight.detach()) + + +def test_transient_non_finite_loss_is_tolerated(tmp_path): + """One overflow must not kill a run — only a sustained streak may. + + The NaN is added as a *constant*, so its gradient contribution is zero and the + weights stay healthy. Multiplying the loss by NaN instead would send NaN into + the weights and every later batch would be non-finite too — which is precisely + why bf16 needs this guard, and which made an earlier version of this test fail + for the right reason. + """ + + class _OneNaNModule(_HealthyModule): + def training_step(self, batch, batch_idx): + x, y = batch + loss = torch.nn.functional.mse_loss(self.layer(x), y) + if self.global_step == 1: + return loss + torch.tensor(float("nan")) + return loss + + module = _OneNaNModule() + trainer = _run(module, tmp_path, precision="bf16-mixed", accelerator="cpu", max_consecutive_nonfinite=3) + assert trainer.current_epoch == 4 + assert torch.isfinite(module.layer.weight).all() + + +def test_accumulation_flat_scale_does_not_reset_the_skip_counter(): + """Batches with no optimizer step leave the scale flat; that must not clear skips. + + Under ``accumulate_grad_batches>1`` the scale only changes on real steps, so a + counter that reset on every unchanged sample would never reach its limit and + the guard would be dead exactly where the bug lives. + """ + guard = OptimizerHealthCheck(max_consecutive_skips=3, min_scale=0.0) + + class _FakeScaler: + def __init__(self) -> None: + self.scale = 65536.0 + + def get_scale(self) -> float: + return self.scale + + scaler = _FakeScaler() + trainer = Namespace(precision_plugin=Namespace(scaler=scaler), global_step=0) + + guard._check_scale(trainer) # first observation, nothing to compare against + for _ in range(2): + scaler.scale /= 2 # a skipped step + guard._check_scale(trainer) + guard._check_scale(trainer) # accumulation batch: scale unchanged + assert guard._consecutive_skips == 2 + + scaler.scale /= 2 + with pytest.raises(OptimizerHealthError, match="halved its scale 3 times"): + guard._check_scale(trainer) + + +def test_scale_growth_clears_the_skip_counter(): + """A successful growth interval means the run recovered; forget the earlier skips.""" + guard = OptimizerHealthCheck(max_consecutive_skips=3, min_scale=0.0) + + class _FakeScaler: + def __init__(self) -> None: + self.scale = 1024.0 + + def get_scale(self) -> float: + return self.scale + + scaler = _FakeScaler() + trainer = Namespace(precision_plugin=Namespace(scaler=scaler), global_step=0) + guard._check_scale(trainer) + scaler.scale /= 2 + guard._check_scale(trainer) + assert guard._consecutive_skips == 1 + scaler.scale *= 2 + guard._check_scale(trainer) + assert guard._consecutive_skips == 0 + + +def test_guard_is_injected_into_a_fit_config(): + """``fit`` configs get the guard even though leaves override ``trainer.callbacks``.""" + config = Namespace(fit=Namespace(trainer=Namespace(callbacks=[]))) + _inject_optimizer_health_guard(config, "fit") + paths = [callback.class_path for callback in config.fit.trainer.callbacks] + assert paths == ["viscy_utils.callbacks.OptimizerHealthCheck"] + + +def test_guard_injection_is_idempotent(): + """Re-running the injector (e.g. a resumed resolved config) must not duplicate it.""" + config = Namespace(fit=Namespace(trainer=Namespace(callbacks=[]))) + _inject_optimizer_health_guard(config, "fit") + _inject_optimizer_health_guard(config, "fit") + assert len(config.fit.trainer.callbacks) == 1 + + +@pytest.mark.parametrize("subcommand", ["predict", "validate", "test", None]) +def test_guard_is_not_injected_outside_fit(subcommand): + """Only training can stall this way; predict/validate configs stay untouched.""" + config = Namespace(**{str(subcommand): Namespace(trainer=Namespace(callbacks=[]))}) + _inject_optimizer_health_guard(config, subcommand) + root = config.get(str(subcommand)) + assert root.trainer.callbacks == [] diff --git a/packages/viscy-utils/src/viscy_utils/cli.py b/packages/viscy-utils/src/viscy_utils/cli.py index 8d9e6b2ad..4329daeff 100644 --- a/packages/viscy-utils/src/viscy_utils/cli.py +++ b/packages/viscy-utils/src/viscy_utils/cli.py @@ -69,6 +69,154 @@ def _configure_wandb_logger( init_args["group"] = base_name +_MODEL_CHECKPOINT_CLASS_PATH = "lightning.pytorch.callbacks.ModelCheckpoint" +_MONITOR_HEALTH_CLASS_PATH = "viscy_utils.callbacks.MonitorHealthCheck" +_OPTIMIZER_HEALTH_CLASS_PATH = "viscy_utils.callbacks.OptimizerHealthCheck" +_LATEST_CKPT_FILENAME = "latest-epoch={epoch}-step={step}" + + +def _callback_field(callback, key: str): + """Return ``key`` from a callback config entry (Namespace or dict), else None.""" + if isinstance(callback, Namespace): + return callback.get(key) + if isinstance(callback, dict): + return callback.get(key) + return None + + +def _init_args_of(callback) -> Namespace | dict | None: + """Return the mutable ``init_args`` mapping of a callback config entry.""" + init_args = _callback_field(callback, "init_args") + return init_args if isinstance(init_args, (Namespace, dict)) else None + + +def _inject_checkpoint_guardrails(config: Namespace, subcommand: str | None) -> None: + """Guarantee latest-weights checkpoints and fail loud on a dead monitor. + + A monitored ``ModelCheckpoint`` writes nothing once ``save_top_k`` is filled + and the metric stops improving — ``last.ckpt`` included, because Lightning + writes it on the same cadence. A frozen or non-finite monitor therefore ends + a run with no weights newer than the first few epochs. + + For ``fit`` only, this appends two callbacks to the resolved config: + + 1. an **unmonitored** ``ModelCheckpoint`` sharing the monitored callback's + ``dirpath`` and **inheriting its ``every_n_epochs``**, which saves on that + cadence unconditionally and owns ``save_last``; and + 2. a :class:`~viscy_utils.callbacks.MonitorHealthCheck` on the same metric. + + ``save_last`` is turned off on the monitored callback so exactly one callback + writes ``last.ckpt`` and that file means "latest weights" rather than "weights + at the last improvement". + + The monitored callback's ``monitor``, ``mode``, ``save_top_k`` and ``filename`` + are deliberately left untouched: those determine which checkpoint a run calls + "best", so changing them would alter model selection and invalidate + comparisons against already-published results. + + This runs on the resolved config rather than the shared trainer recipe because + leaves override ``trainer.callbacks`` wholesale to set their own ``dirpath`` — + a recipe-level default would be silently dropped by every real leaf. + """ + if subcommand != "fit": + return + root = config.get(subcommand) if subcommand is not None else config + if not isinstance(root, Namespace): + return + trainer = root.get("trainer") + if not isinstance(trainer, Namespace): + return + callbacks = trainer.get("callbacks") + if not isinstance(callbacks, list): + return + + # Idempotent: a config that already carries the guardrails is left alone. + for callback in callbacks: + if _callback_field(callback, "class_path") == _MONITOR_HEALTH_CLASS_PATH: + return + + monitored = None + for callback in callbacks: + if _callback_field(callback, "class_path") != _MODEL_CHECKPOINT_CLASS_PATH: + continue + init_args = _init_args_of(callback) + if init_args is not None and init_args.get("monitor"): + monitored = callback + break + if monitored is None: + return + + monitored_args = _init_args_of(monitored) + monitor = monitored_args.get("monitor") + dirpath = monitored_args.get("dirpath") + # Hand `last.ckpt` to the unconditional callback so it tracks the newest epoch. + monitored_args["save_last"] = False + + # Inherit the leaf's write cadence instead of forcing every epoch. A leaf that + # sets `every_n_epochs` is making a deliberate write-amplification decision: + # the Phase 17 arms run ~1470 epochs, so `every_n_epochs: 10` is the difference + # between 147 and 1470 write cycles of a 424 MB checkpoint, and this callback + # writes *two* files (`latest-*` and `last.ckpt`) each time -- ~1.25 TB of NFS + # traffic per arm at cadence 1. Forcing 1 here silently overrode that choice. + # + # The guarantee is unaffected: an *unmonitored* callback writes on its cadence + # unconditionally, so the newest weights are always within `every_n_epochs` + # epochs of where the run stopped, however dead the monitor is. Defaults to 1 + # when the leaf is silent, preserving the original behaviour. + every_n_epochs = monitored_args.get("every_n_epochs") or 1 + + latest_args = { + "monitor": None, + "filename": _LATEST_CKPT_FILENAME, + "auto_insert_metric_name": False, + "every_n_epochs": every_n_epochs, + "save_top_k": 1, + "save_last": True, + } + if dirpath is not None: + latest_args["dirpath"] = dirpath + callbacks.append(Namespace(class_path=_MODEL_CHECKPOINT_CLASS_PATH, init_args=Namespace(**latest_args))) + callbacks.append( + Namespace(class_path=_MONITOR_HEALTH_CLASS_PATH, init_args=Namespace(monitor=monitor, patience=10)) + ) + + +def _inject_optimizer_health_guard(config: Namespace, subcommand: str | None) -> None: + """Attach the step-level optimizer guard to every ``fit`` run. + + A NaN *gradient* is invisible to loss-based monitoring. Under ``16-mixed``, + ``GradScaler`` skips the step and halves its scale while the forward — and the + logged loss — stays finite; once the scale reaches ``0.0`` every step is + skipped for the rest of the run and the weights never move again. Under + ``bf16-mixed`` there is no scaler, so the NaN lands in the weights instead. + :class:`~viscy_utils.callbacks.OptimizerHealthCheck` covers both. + + Injected here rather than in the shared trainer recipe for the same reason as + the checkpoint guardrails: leaves override ``trainer.callbacks`` wholesale to + set their own ``dirpath``, so a recipe-level default is silently dropped by + every real leaf. Injecting on the resolved config makes it unforgettable. + + Unlike :func:`_inject_checkpoint_guardrails` this does not depend on the leaf + declaring a monitored ``ModelCheckpoint`` — a run with no checkpointing at all + can still stall — so it only requires a ``trainer.callbacks`` list to append to. + """ + if subcommand != "fit": + return + root = config.get(subcommand) if subcommand is not None else config + if not isinstance(root, Namespace): + return + trainer = root.get("trainer") + if not isinstance(trainer, Namespace): + return + callbacks = trainer.get("callbacks") + if not isinstance(callbacks, list): + return + for callback in callbacks: + if _callback_field(callback, "class_path") == _OPTIMIZER_HEALTH_CLASS_PATH: + return + callbacks.append(Namespace(class_path=_OPTIMIZER_HEALTH_CLASS_PATH)) + + class VisCyCLI(LightningCLI): """Extending lightning CLI arguments and defaults.""" @@ -127,6 +275,8 @@ def _parse_ckpt_path(self) -> None: def before_instantiate_classes(self) -> None: """Apply shared config rewrites before Lightning object creation.""" _configure_wandb_logger(self.config, self.subcommand) + _inject_checkpoint_guardrails(self.config, self.subcommand) + _inject_optimizer_health_guard(self.config, self.subcommand) def _setup_environment() -> None: diff --git a/packages/viscy-utils/tests/test_cli.py b/packages/viscy-utils/tests/test_cli.py index e8835f983..a086b535c 100644 --- a/packages/viscy-utils/tests/test_cli.py +++ b/packages/viscy-utils/tests/test_cli.py @@ -19,7 +19,9 @@ def _run(*args): [sys.executable, "-m", "viscy_utils.cli", *args], capture_output=True, text=True, - timeout=30, + # Hang guard only. A cold `--help` imports torch/lightning from NFS: + # 12-22 s serially, and past 30 s under `pytest -n 11`. + timeout=120, ) return _run From 13173137233a91c4f3a0d9269a3f99080a104f7d Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:48:04 -0700 Subject: [PATCH 05/72] fix(viscy-utils): keep SSIM finite under mixed precision; lazy exports Port two viscy-utils changes from dynacell-models: - ssim_25d / ms_ssim_25d: clamp the variances, bound the covariance by Cauchy-Schwarz through a safe sqrt, floor the stability constants symmetrically, and run MS-SSIM outside autocast, so 16-mixed training cannot NaN the gradient. SSIM/MS-SSIM loss values change slightly for MixedLoss users. - viscy_utils/__init__ resolves its exports lazily (PEP 562), keeping torch and lightning off light import paths. Source on dynacell-models: a556bc9d (#484), 130e0340, cee4e41f, 272051c0, 59343ad0, 8b2413f5 (#509). Co-Authored-By: Claude Opus 5.5 --- .../viscy-utils/src/viscy_utils/__init__.py | 42 ++-- .../src/viscy_utils/evaluation/metrics.py | 119 +++++++++-- .../viscy-utils/tests/test_lazy_imports.py | 38 ++++ packages/viscy-utils/tests/test_metrics.py | 200 +++++++++++++++++- 4 files changed, 370 insertions(+), 29 deletions(-) create mode 100644 packages/viscy-utils/tests/test_lazy_imports.py diff --git a/packages/viscy-utils/src/viscy_utils/__init__.py b/packages/viscy-utils/src/viscy_utils/__init__.py index c1ad90903..266c0387e 100644 --- a/packages/viscy-utils/src/viscy_utils/__init__.py +++ b/packages/viscy-utils/src/viscy_utils/__init__.py @@ -1,17 +1,27 @@ -from viscy_utils.log_images import detach_sample, render_images -from viscy_utils.mp_utils import get_val_stats, mp_wrapper -from viscy_utils.normalize import hist_clipping, unzscore, zscore -from viscy_utils.optimizers import configure_adamw_scheduler -from viscy_utils.tensor_utils import to_numpy +import importlib -__all__ = [ - "configure_adamw_scheduler", - "detach_sample", - "get_val_stats", - "hist_clipping", - "mp_wrapper", - "render_images", - "to_numpy", - "unzscore", - "zscore", -] +# Resolved lazily (PEP 562) so importing a light submodule such as +# ``viscy_utils.prediction_metadata`` does not pull in torch and lightning. +_LAZY_ATTRS = { + "configure_adamw_scheduler": "viscy_utils.optimizers", + "detach_sample": "viscy_utils.log_images", + "get_val_stats": "viscy_utils.mp_utils", + "hist_clipping": "viscy_utils.normalize", + "mp_wrapper": "viscy_utils.mp_utils", + "render_images": "viscy_utils.log_images", + "to_numpy": "viscy_utils.tensor_utils", + "unzscore": "viscy_utils.normalize", + "zscore": "viscy_utils.normalize", +} + +__all__ = list(_LAZY_ATTRS) + + +def __getattr__(name: str): + if name not in _LAZY_ATTRS: + raise AttributeError(f"module {__name__!r} has no attribute {name!r}") + return getattr(importlib.import_module(_LAZY_ATTRS[name]), name) + + +def __dir__() -> list[str]: + return sorted([*globals(), *__all__]) diff --git a/packages/viscy-utils/src/viscy_utils/evaluation/metrics.py b/packages/viscy-utils/src/viscy_utils/evaluation/metrics.py index de293b5c8..4148db300 100644 --- a/packages/viscy-utils/src/viscy_utils/evaluation/metrics.py +++ b/packages/viscy-utils/src/viscy_utils/evaluation/metrics.py @@ -171,6 +171,42 @@ def mean_average_precision( return map_metric.compute() +# Floors the SSIM/CS denominators so a zero data_range (c1=c2=0) on a flat window +# cannot produce 0/0; negligible relative to the c1/c2 stability constants otherwise. +_SSIM_DENOM_EPS: float = 1e-8 + + +def _safe_sqrt(x: torch.Tensor) -> torch.Tensor: + """Square root whose derivative at exactly zero is 0 rather than infinite. + + ``torch.sqrt`` backward is ``grad_out * 0.5 / sqrt(x)``, which is ``inf`` at + ``x == 0``. For the elements whose incoming ``grad_out`` is *itself* zero that + evaluates to ``0 * inf == nan``, so a single zero entry poisons the gradient + of every element in its convolution window — the forward pass stays perfectly + finite while the backward pass silently fills with NaN. + + Guarding with ``clamp_min(eps)`` or ``sqrt(x + eps)`` does not fix this: both + perturb the forward value and still leave a ``1 / (2 * sqrt(eps))`` gradient + spike. Instead substitute a dummy positive value *before* the square root and + restore the true zero after, so the ``sqrt`` node never sees zero and its + backward never divides by it. The forward result is bit-identical to + ``x.sqrt()`` and the gradient is bit-identical wherever ``x > 0``; only the + ``x == 0`` entries change, from NaN to 0. + + Parameters + ---------- + x : torch.Tensor + Non-negative input tensor. + + Returns + ------- + torch.Tensor + ``sqrt(x)``, with a zero subgradient at the exact zeros of ``x``. + """ + positive = x > 0 + return torch.where(positive, torch.where(positive, x, torch.ones_like(x)).sqrt(), torch.zeros_like(x)) + + def _compute_ssim_and_cs_bf16( y_pred: torch.Tensor, y: torch.Tensor, @@ -259,12 +295,64 @@ def _compute_ssim_and_cs_bf16( c1 = (k1 * data_range) ** 2 c2 = (k2 * data_range) ** 2 - sigma_x = mu_xx - mu_x * mu_x - sigma_y = mu_yy - mu_y * mu_y - sigma_xy = mu_xy - mu_x * mu_y - - contrast_sensitivity = (2 * sigma_xy + c2) / (sigma_x + sigma_y + c2) - ssim_full = ((2 * mu_x * mu_y + c1) / (mu_x * mu_x + mu_y * mu_y + c1)) * contrast_sensitivity + # Repair bf16 catastrophic cancellation in the second moments. With bf16 + # mean / mean-of-squares convolutions, ``mu_xx - mu_x**2`` cancels badly for + # windows over large-magnitude inputs (e.g. z-scored FCMAE targets with a tiny + # iqr → normalized values in the hundreds) and can round to a slightly *negative* + # variance. At depth=1 (2D) each window has only ``1*H_k*W_k`` samples, so the + # cancellation is far more likely than at depth=15 (3D, where the extra Z samples + # keep the estimate stable) — a near-flat window then drives the SSIM denominator + # to ~0 and produces intermittent NaN loss that trains fine for a while then + # diverges. + # + # A variance is non-negative by definition, so clamp both diagonal terms to >=0. + # The covariance must then be bounded by Cauchy-Schwarz (|sigma_xy| <= + # sqrt(sigma_x*sigma_y)): exact fp32 recovers cs=1 on a flat window because the + # equally-negative sigma_x/sigma_y/sigma_xy cancel in the ratio, so clamping only + # the diagonal terms would leave an unbalanced negative sigma_xy and inflate |cs| + # to >10 on background windows. With the bound a flat window gives + # sigma_x=sigma_y=sigma_xy=0 -> cs = c2 / c2 = 1, matching exact fp32; on + # well-conditioned windows the bound is slack and both clamps are no-ops. + # + # The bound goes through ``_safe_sqrt``, not ``sqrt``: the same cancellation that + # motivates the clamp also drives ``sigma_x * sigma_y`` to *exactly* zero (either + # term rounds to 0), and ``sqrt`` has an infinite derivative there. Autograd then + # produces ``0 * inf == nan`` for the clamp-inactive elements, which spreads + # through the conv backward and NaNs most of the input gradient while the forward + # loss stays finite. + # + # That guards the fp32 path only. A NaN also reaches this line's ``MulBackward0`` + # when an enclosing 16-mixed autocast is left enabled, which ``ssim_25d`` now + # prevents -- see the note at its call site. Do not "fix" that by detaching the + # bound: the clamp binds often enough on ordinary inputs that the bound carries + # real gradient, and detaching drops the helper's gradient agreement with the + # fp32 monai reference from cosine 0.99 to 0.79 + # (``test_ssim_helper_gradient_flow``). + # + # Exposure depends on the per-window mean-to-variance ratio, so it is a latent + # trap rather than a constant hazard. Synthetic z-scored fields with a flat + # background at a nonzero offset reach 41-48% of ``pred.grad``; real z-scored + # iPSC FOVs measured 0% at depth=15 and 0-6484 NaN entries at depth=1, and a + # 60-step run of the real FCMAE-2D model on a real batch did not trip + # ``GradScaler`` at all. Treat this as a correctness fix for a reachable + # gradient path, not as a diagnosis of any particular run. + sigma_x = (mu_xx - mu_x * mu_x).clamp_min(0.0) + sigma_y = (mu_yy - mu_y * mu_y).clamp_min(0.0) + sigma_xy_bound = _safe_sqrt(sigma_x * sigma_y) + sigma_xy = torch.clamp(mu_xy - mu_x * mu_y, min=-sigma_xy_bound, max=sigma_xy_bound) + + # ``_SSIM_DENOM_EPS`` floors the stability constants so a zero data_range (→ c1=c2=0) + # on a flat window cannot yield 0/0. It goes in the NUMERATOR as well as the + # denominator -- exactly c1 -> c1 + eps, c2 -> c2 + eps -- because SSIM(x, x) == 1 + # only holds when the same constant appears in both. Flooring the denominator alone + # gave SSIM(y, y) = 0.082 at data_range 1e-3 and 0.0 at data_range 0, and + # ``ms_ssim_25d`` recomputes data_range from a downsampled target per scale, so an + # all-zero crop scored loss 1.0 for a numerically perfect prediction. Negligible vs + # c1/c2 otherwise: max 2.2e-4 relative on ordinary inputs. + contrast_sensitivity = (2 * sigma_xy + c2 + _SSIM_DENOM_EPS) / (sigma_x + sigma_y + c2 + _SSIM_DENOM_EPS) + ssim_full = ( + (2 * mu_x * mu_y + c1 + _SSIM_DENOM_EPS) / (mu_x * mu_x + mu_y * mu_y + c1 + _SSIM_DENOM_EPS) + ) * contrast_sensitivity return ssim_full, contrast_sensitivity @@ -291,12 +379,19 @@ def ssim_25d( depth = preds.shape[2] if depth > 15: warn(f"Input depth {depth} is potentially too large for 2.5D SSIM.") - ssim_img, cs_img = _compute_ssim_and_cs_bf16( - preds, - target, - kernel_size=(depth, *in_plane_window_size), - data_range=target.max(), - ) + # Outside autocast: this helper picks its own precision on purpose (bf16 convs, + # fp32 for everything after), and letting an enclosing 16-mixed autocast re-enter + # it puts backward intermediates in fp16, where the ~1e8 gradients the floored + # SSIM denominator produces overflow to inf and a later multiply turns them into + # NaN. Measured on the captured failing batch: 0.02% NaN under autocast, 0.00% in + # fp32, with the forward differing by ~3e-6. + with torch.amp.autocast(device_type=preds.device.type, enabled=False): + ssim_img, cs_img = _compute_ssim_and_cs_bf16( + preds, + target, + kernel_size=(depth, *in_plane_window_size), + data_range=target.max(), + ) # aggregate to one scalar per batch ssim = ssim_img.view(ssim_img.shape[0], -1).mean(1) if return_contrast_sensitivity: diff --git a/packages/viscy-utils/tests/test_lazy_imports.py b/packages/viscy-utils/tests/test_lazy_imports.py new file mode 100644 index 000000000..85036d8d4 --- /dev/null +++ b/packages/viscy-utils/tests/test_lazy_imports.py @@ -0,0 +1,38 @@ +import subprocess +import sys + +import pytest + +import viscy_utils + +# Submodules that evaluation code imports without training anything. +LIGHT_SUBMODULES = [ + "viscy_utils.compose", + "viscy_utils.mp_utils", + "viscy_utils.normalize", + "viscy_utils.prediction_metadata", +] + + +def test_light_submodules_skip_torch_and_lightning(): + """Importing light submodules must not load torch or lightning via the package.""" + code = ( + f"import sys, {', '.join(LIGHT_SUBMODULES)}; " + "print(sorted(m for m in ('torch', 'lightning') if m in sys.modules))" + ) + result = subprocess.run([sys.executable, "-c", code], capture_output=True, text=True, check=True) + assert result.stdout.strip() == "[]" + + +@pytest.mark.parametrize("name", viscy_utils.__all__) +def test_public_names_importable(name): + exec(f"from viscy_utils import {name}", {}) + + +def test_unknown_attribute_raises(): + with pytest.raises(AttributeError): + viscy_utils.not_a_name # noqa: B018 + + +def test_dir_lists_public_names(): + assert set(viscy_utils.__all__) <= set(dir(viscy_utils)) diff --git a/packages/viscy-utils/tests/test_metrics.py b/packages/viscy-utils/tests/test_metrics.py index 6f1d3eb51..0dfc6688b 100644 --- a/packages/viscy-utils/tests/test_metrics.py +++ b/packages/viscy-utils/tests/test_metrics.py @@ -7,13 +7,27 @@ - aggregate SSIM equivalence on correlated-pair inputs (closer to training) - gradient-flow correctness via cosine similarity and sign-flip fraction - output dtype invariance to input dtype +- finiteness at zero data_range (the eps denominator floor) +- flat-window contrast-sensitivity ≈ 1 (the Cauchy-Schwarz covariance bound) +- finite gradients on flat-background windows (sqrt-at-zero inside that same bound) +- MS-SSIM computes outside autocast, so fp16 backward intermediates cannot overflow + to inf and become NaN in a later multiply + +The two regression tests guard the deterministic, hardware-independent halves of +the bf16 NaN fix. The remaining half — the negative-variance denominator collapse +that produced intermittent NaN loss in 2D FCMAE training — is a bf16 rounding +knife-edge (the denominator must round to exactly 0) that only surfaces over +millions of windows across many steps and varies by GPU architecture, so it is not +unit-reproducible; it is validated end-to-end (the exact failing fit ran clean +after the clamp). """ import pytest import torch import torch.nn.functional as F -from viscy_utils.evaluation.metrics import _compute_ssim_and_cs_bf16 +from viscy_utils.evaluation import metrics as metrics_module +from viscy_utils.evaluation.metrics import _compute_ssim_and_cs_bf16, _safe_sqrt # monai is not a hard dep of viscy-utils — skip the suite if absent rather # than failing at import time. @@ -167,3 +181,187 @@ def test_ssim_helper_dtypes(input_dtype): assert ssim_helper.dtype == torch.float32 assert cs_helper.dtype == torch.float32 + + +@_skip_no_bf16 +def test_ssim_helper_finite_on_zero_data_range(): + """Regression: a zero ``data_range`` (→ c1=c2=0) must not yield 0/0 NaN. + + ``ms_ssim_25d`` recomputes ``data_range = target.max()`` per scale; a flat or + all-nonpositive target zeroes ``data_range`` and with it the c1/c2 stability + constants, so the SSIM/CS ratios become 0/0. ``clamp=True`` in the loss cannot + repair that — ``clamp`` bounds magnitude, not NaN — so the poisoned gradient + silently corrupts every weight. The ``_SSIM_DENOM_EPS`` denominator floor keeps + the helper finite. This case NaNs on the unfloored implementation on every device + (deterministic, hardware-independent). + """ + kernel_1 = (1, 11, 11) + shape = (2, 1, 1, 64, 64) + y = torch.zeros(*shape, device="cuda") + y_pred = torch.zeros_like(y) + + ssim_full, cs = _compute_ssim_and_cs_bf16(y_pred, y, kernel_size=kernel_1, data_range=y.max()) + + assert torch.isfinite(ssim_full).all(), "SSIM NaN/Inf at data_range=0 (denominator not floored)" + assert torch.isfinite(cs).all(), "contrast-sensitivity NaN/Inf at data_range=0" + + +@_skip_no_bf16 +def test_ssim_helper_identity_holds_at_small_data_range(): + """SSIM(y, y) == 1 for every ``data_range``, including 0. + + ``_SSIM_DENOM_EPS`` must floor c1/c2 SYMMETRICALLY -- numerator and denominator. + Flooring only the denominator keeps the helper finite (the sibling test above) + but breaks the identity: measured SSIM(y, y) = 0.082158 at data_range 1e-3 and + exactly 0.0 at data_range 0. Since ``ms_ssim_25d`` recomputes + ``data_range = target.max()`` per scale from a downsampled target, an all-zero + or masked-out crop then scored loss 1.0 for a numerically perfect prediction. + """ + shape = (2, 1, 1, 64, 64) + for value in (0.0, 1e-4, 1e-3, 3e-3, 1e-2, 1.0): + y = torch.full(shape, value, device="cuda") + ssim_full, cs = _compute_ssim_and_cs_bf16(y, y, kernel_size=(1, 11, 11), data_range=y.max()) + assert torch.isfinite(ssim_full).all() + assert abs(ssim_full.mean().item() - 1.0) < 1e-6, f"SSIM(y, y) != 1 at data_range={value}" + assert abs(cs.mean().item() - 1.0) < 1e-6, f"cs(y, y) != 1 at data_range={value}" + + zeros = torch.zeros(1, 1, 5, 256, 256, device="cuda") + assert abs(metrics_module.ms_ssim_25d(zeros, zeros, clamp=True).item() - 1.0) < 1e-6 + + +@_skip_no_bf16 +def test_ssim_helper_flat_window_contrast_is_unity(): + """Regression: near-flat windows over large-magnitude inputs keep cs≈1. + + FCMAE targets are z-scored (``NormalizeSampled``); a channel with a tiny iqr + (e.g. iPSC/A549 nucleus, iqr~1.8) normalizes to values in the hundreds. At + depth=1 (2D FCMAE) each SSIM window has only ``1*H_k*W_k`` samples, so the bf16 + ``mu_xx - mu_x**2`` variance estimate catastrophically cancels and rounds + *negative* (empirically ~-100 at magnitude 150). Exact fp32 recovers cs=1 on a + flat window because the equally-negative sigma_x/sigma_y/sigma_xy cancel in the + ratio; clamping only the diagonal variances to >=0 breaks that cancellation and + inflates |cs| past 10 on background windows (which dominate a VS image). The + Cauchy-Schwarz bound on sigma_xy restores cs=1. This guards that balance — the + unbounded-covariance variant fails it with |cs-1| > 10, deterministically. + """ + torch.manual_seed(5) + kernel_1 = (1, 11, 11) + shape = (1, 1, 1, 64, 64) + worst = 0.0 + for magnitude in (150.0, 300.0): + y = torch.full(shape, magnitude, device="cuda") + 0.03 * torch.randn(*shape, device="cuda") + y_pred = torch.full(shape, magnitude, device="cuda") + 0.03 * torch.randn(*shape, device="cuda") + _, cs = _compute_ssim_and_cs_bf16( + y_pred, y, kernel_size=kernel_1, data_range=torch.tensor(magnitude, device="cuda") + ) + assert torch.isfinite(cs).all() + worst = max(worst, (cs - 1.0).abs().max().item()) + assert worst < 0.5, f"near-flat contrast-sensitivity deviates from 1 by {worst:.3f} (unbounded covariance?)" + + +@_skip_no_bf16 +def test_ssim_helper_gradient_finite_on_flat_background(): + """Regression: the Cauchy-Schwarz bound must not NaN the gradient at zero variance. + + ``sigma_xy_bound = sqrt(sigma_x * sigma_y)`` is zero wherever either clamped + variance rounds to zero, and ``sqrt`` has an infinite derivative at zero. The + clamp-inactive elements contribute ``0 * inf == nan``, which the conv backward + then spreads across each window — so the forward loss stays finite while most of + the input gradient becomes NaN. On the unguarded ``sqrt`` this fires on ordinary + normalized batches: 41-48% of ``pred.grad`` for a z-scored field with a flat + background at a nonzero offset, at both depth=15 and depth=1. + + Uses an offset flat region rather than ``torch.rand``: the trigger is a window + whose mean dominates its variance, so ``mu_xx`` and ``mu_x**2`` round to the same + bf16 value and cancel exactly. + """ + torch.manual_seed(6) + shape = (2, 1, 15, 192, 192) + half = shape[-2] // 2 + + def _field(seed: int) -> torch.Tensor: + torch.manual_seed(seed) + field = torch.randn(*shape, device="cuda") * 0.1 - 0.5 + # Bottom half carries structure; the top half stays near-flat background. + field[..., half:, :] = torch.randn(shape[0], shape[1], shape[2], shape[-2] - half, shape[-1], device="cuda") + return field + + y_pred = _field(6).detach().requires_grad_(True) + y = _field(7) + + ssim_full, _ = _compute_ssim_and_cs_bf16(y_pred, y, kernel_size=_KERNEL, data_range=y.max()) + (1 - ssim_full.mean()).backward() + + assert y_pred.grad is not None + n_nan = torch.isnan(y_pred.grad).sum().item() + assert n_nan == 0, f"{n_nan}/{y_pred.grad.numel()} NaN gradients (sqrt of zero variance not guarded)" + + +@_skip_no_bf16 +def test_ms_ssim_runs_outside_autocast(): + """``ms_ssim_25d`` must compute in fp32 even inside a 16-mixed autocast region. + + The helper chooses its own precision deliberately -- bf16 convolutions, fp32 for + everything after. Letting an enclosing autocast re-enter it puts *backward* + intermediates in fp16, where the ~1e8 gradients produced by the floored SSIM + denominator overflow to inf and a later multiply turns them into NaN. That is the + failure that stalled three joint FCMAE resumes: ``detect_anomaly`` blamed + ``MulBackward0`` on the Cauchy-Schwarz bound, the forward loss stayed finite, and + every one of the model's 32.1 M parameter gradients came back NaN. + + Pins the structural invariant, because reproducing the NaN itself needs one + specific real batch (z-scored targets ranging to ~264) far too large to ship as a + fixture: on that batch the rate was 0.02% of the input gradient under autocast and + exactly 0% in fp32. Hardening ``sqrt`` does not cover this and neither does + splitting the product -- both were measured and both still NaN'd. + """ + seen = [] + real = metrics_module._compute_ssim_and_cs_bf16 + + def spy(*args, **kwargs): + seen.append(torch.is_autocast_enabled()) + return real(*args, **kwargs) + + y = torch.rand(*_BATCH, device="cuda") + y_pred = (y + 0.05 * torch.randn_like(y)).detach().requires_grad_(True) + + monkey = pytest.MonkeyPatch() + monkey.setattr("viscy_utils.evaluation.metrics._compute_ssim_and_cs_bf16", spy) + try: + with torch.autocast("cuda", dtype=torch.float16): + ms_ssim = metrics_module.ms_ssim_25d(y_pred, y, clamp=True) + (1 - ms_ssim).backward() + finally: + monkey.undo() + + assert seen, "ms_ssim_25d did not reach the bf16 helper" + assert not any(seen), ( + f"autocast was enabled for {sum(seen)}/{len(seen)} MS-SSIM scales; fp16 backward intermediates are the NaN path" + ) + assert torch.isfinite(y_pred.grad).all(), "non-finite gradient under 16-mixed autocast" + + +def test_safe_sqrt_matches_sqrt_forward_and_zeroes_gradient_at_zero(): + """``_safe_sqrt`` is bit-exact vs ``sqrt`` forward, and finite in backward at 0. + + Runs on CPU — the sqrt-at-zero derivative is a pure autograd property with no + bf16 or CUDA involvement. Pins both halves of the contract the SSIM bound relies + on: identical forward values, identical gradients where the input is positive, + and a zero (not NaN) gradient at the exact zeros. + """ + values = torch.tensor([0.0, 1e-12, 0.25, 1.0, 4.0]) + + plain = values.detach().clone().requires_grad_(True) + plain.sqrt().sum().backward() + + safe = values.detach().clone().requires_grad_(True) + safe_out = _safe_sqrt(safe) + safe_out.sum().backward() + + torch.testing.assert_close(safe_out, values.sqrt(), rtol=0, atol=0) + assert torch.isfinite(safe.grad).all(), f"safe grad not finite: {safe.grad}" + assert safe.grad[0] == 0.0, f"expected zero gradient at x=0, got {safe.grad[0]}" + # Unguarded sqrt is the failure being guarded against. + assert not torch.isfinite(plain.grad[0]), "expected unguarded sqrt to blow up at x=0" + # Everywhere the input is positive the two must agree bit-for-bit. + torch.testing.assert_close(safe.grad[1:], plain.grad[1:], rtol=0, atol=0) From 4a6943acfc854e633231d8b0e5246c9bb6379c15 Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:48:15 -0700 Subject: [PATCH 06/72] feat(viscy-data): slab-only and read-once predict, uint8 foreground masks Port the viscy-data side of the dynacell-models predict and Spotlight work: - HCSDataModule.predict_z_planes and SlidingWindowDataset z_planes / read_z_planes, so a 2D model predicts only its focus slab; - cache_volume: with num_workers == 0 predict reads each (position, t) volume once and, when every transform is pointwise, normalizes it once; - foreground masks are read in their stored dtype (uint8) and cast to float on the device in on_after_batch_transfer. Behavior change: every app's predict at num_workers=0 takes the read-once path. Source on dynacell-models: 40de7939 (#498), 996adb47 (#526), 6c83fff4 (#531), 8e74a7eb (#532). Co-Authored-By: Claude Opus 5.5 --- .../src/viscy_data/foreground_masks.py | 9 +- packages/viscy-data/src/viscy_data/hcs.py | 21 ++- .../src/viscy_data/sliding_window.py | 136 +++++++++++++++++- packages/viscy-data/tests/test_hcs.py | 122 +++++++++++++++- 4 files changed, 278 insertions(+), 10 deletions(-) diff --git a/packages/viscy-data/src/viscy_data/foreground_masks.py b/packages/viscy-data/src/viscy_data/foreground_masks.py index 2489f72f3..58404fd22 100644 --- a/packages/viscy-data/src/viscy_data/foreground_masks.py +++ b/packages/viscy-data/src/viscy_data/foreground_masks.py @@ -159,11 +159,14 @@ def read_window( Returns ------- list[Tensor] - Per-channel mask tensors with shape ``(1, Z, Y, X)``. + Per-channel mask tensors with shape ``(1, Z, Y, X)``, in the + stored dtype (not upcast: a float32 mask quadruples the mask's + share of every worker buffer and pinned host copy, which + OOM-killed the 4-GPU 3D seg-aux fits at their first validation). """ - kwargs = {} + kwargs = {"as_float": False} if self._preloaded_masks is not None: - kwargs = {"arr_idx": arr_idx, "_preloaded": self._preloaded_masks} + kwargs.update(arr_idx=arr_idx, _preloaded=self._preloaded_masks) mask_images, _ = read_fn( self._mask_arrays[arr_idx], self._mask_ch_indices[arr_idx], diff --git a/packages/viscy-data/src/viscy_data/hcs.py b/packages/viscy-data/src/viscy_data/hcs.py index eb7bc7502..28df3869e 100644 --- a/packages/viscy-data/src/viscy_data/hcs.py +++ b/packages/viscy-data/src/viscy_data/hcs.py @@ -28,7 +28,7 @@ from viscy_data._typing import Sample from viscy_data._utils import _collate_samples, _ensure_channel_list from viscy_data.foreground_masks import ForegroundMaskSupport -from viscy_data.sliding_window import MaskTestDataset, SlidingWindowDataset +from viscy_data.sliding_window import MaskTestDataset, SlidingWindowDataset, read_z_planes _logger = logging.getLogger("lightning.pytorch") @@ -119,6 +119,12 @@ class HCSDataModule(LightningDataModule): ``include_fov_names``. Stored as a ``set`` for O(1) lookup. Honored during fit/validate (including mmap staging) and predict. Test stage uses all plate positions. + predict_z_planes : str or Path or None, optional + Plane file (see :func:`viscy_data.sliding_window.read_z_planes`) that + restricts predict to the listed Z planes per position and timepoint, e.g. + the in-focus slab of a 2D model. Requires ``z_window_size == 1``. The + prediction writer allocates the full source shape and records the planes + on each position. Default None predicts every plane. Predict only. """ def __init__( @@ -151,6 +157,7 @@ def __init__( val_gpu_augmentations: list[MapTransform] | None = None, include_fov_names: Iterable[str] | None = None, exclude_fov_names: Iterable[str] | None = None, + predict_z_planes: str | Path | None = None, ): super().__init__() self.data_path = Path(data_path) @@ -185,6 +192,7 @@ def __init__( self.val_augmentations = val_augmentations or [] self.include_fov_names = set(include_fov_names) if include_fov_names is not None else None self.exclude_fov_names = set(exclude_fov_names) if exclude_fov_names is not None else None + self.predict_z_planes = Path(predict_z_planes) if predict_z_planes is not None else None if gpu_augmentations and self.fg_mask_key is not None: ForegroundMaskSupport.patch_spatial_transforms(gpu_augmentations, ("target",), ("fg_mask",)) if val_gpu_augmentations and self.fg_mask_key is not None: @@ -670,9 +678,16 @@ def _setup_predict( # never reads it, and inference datasets may not have the array. dataset_settings.pop("fg_mask_key", None) predict_transform = Compose(self.normalizations) + z_planes = read_z_planes(self.predict_z_planes) if self.predict_z_planes is not None else None self.predict_dataset = SlidingWindowDataset( positions=self._positions_maybe_single(), transform=predict_transform, + z_planes=z_planes, + # Read each volume once and cut its depth windows from memory. A plane + # selection reads single planes, where a whole-volume read would only cost, + # and loader workers each take every Nth batch, so each would read the whole + # volume. + cache_volume=z_planes is None and self.num_workers == 0, **dataset_settings, ) @@ -691,6 +706,10 @@ def on_after_batch_transfer(self, batch: Sample, dataloader_idx: int) -> Sample: """ if isinstance(batch, Tensor): return batch + # Masks travel host-side in their stored dtype (uint8) to keep worker + # and pinned buffers small; augmentations and losses expect float. + if "fg_mask" in batch and not batch["fg_mask"].is_floating_point(): + batch["fg_mask"] = batch["fg_mask"].float() if self.trainer and self.trainer.training and self._gpu_augmentations is not None: batch = self._gpu_augmentations(batch) elif ( diff --git a/packages/viscy-data/src/viscy_data/sliding_window.py b/packages/viscy-data/src/viscy_data/sliding_window.py index 7e109f555..0978aed66 100644 --- a/packages/viscy-data/src/viscy_data/sliding_window.py +++ b/packages/viscy-data/src/viscy_data/sliding_window.py @@ -1,7 +1,10 @@ """Sliding window datasets for HCS NGFF stores.""" import bisect +import json import logging +from collections.abc import Mapping, Sequence +from os import PathLike from pathlib import Path import numpy as np @@ -18,6 +21,29 @@ _logger = logging.getLogger("lightning.pytorch") +def read_z_planes(path: str | PathLike) -> dict[str, list[list[int]]]: + """Read a predict plane file: position name -> one Z-plane list per timepoint. + + The file is JSON with a ``positions`` mapping (``{"A/1/0": [[11, 12, 13], ...]}``); + any other top-level keys are provenance (how the planes were chosen) and are + ignored here. + + Parameters + ---------- + path : str or PathLike + Plane file written by the producer of the planes (dynacell writes them with + ``precompute-gt build.focus_planes``). + + Returns + ------- + dict[str, list[list[int]]] + Plate-relative position name to per-timepoint plane lists. + """ + with open(path) as f: + payload = json.load(f) + return {name: [[int(z) for z in planes] for planes in per_t] for name, per_t in payload["positions"].items()} + + class SlidingWindowDataset(Dataset): """Sliding window dataset over HCS NGFF positions. @@ -61,6 +87,24 @@ class SlidingWindowDataset(Dataset): ``(T, C, Z, Y, X)``. Channels are ``source + target`` in order. When set, bypasses zarr reads via ``.clone()`` copies from the preloaded data. Default None reads from zarr. + z_planes : Mapping[str, Sequence[Sequence[int]]] or None + Restrict the windows to these Z planes: plate-relative position name + (``"A/1/0"``) to one plane list per timepoint (see :func:`read_z_planes`). + Requires ``z_window_size == 1``; every position needs an entry with one list + per timepoint. Windows stay in increasing ``z`` order within a timepoint. + Default None takes every plane. + cache_volume : bool + Read each (position, timepoint) volume from zarr once and cut its windows + from that copy, instead of re-reading every window. Stride-1 depth windows + otherwise read each plane once per window covering it. Pays off when the + windows of a volume are requested consecutively (the sequential predict + loader); random access (training) would read a whole volume per window. + Each DataLoader worker would keep its own copy and read the whole volume, + so :class:`HCSDataModule` enables it only with ``num_workers == 0``. Not + combinable with ``fg_mask_key`` or ``min_nonzero_fraction``. When every + transform is ``pointwise`` (each voxel mapped through precomputed + statistics alone, e.g. ``NormalizeSampled``), the cached volume is + transformed once instead of every window. Default False. """ def __init__( @@ -77,8 +121,29 @@ def __init__( max_nonzero_retries: int = 100, fg_mask_key: str | None = None, preloaded_fovs: list[Tensor] | None = None, + z_planes: Mapping[str, Sequence[Sequence[int]]] | None = None, + cache_volume: bool = False, ) -> None: super().__init__() + if cache_volume and fg_mask_key is not None: + raise ValueError("cache_volume caches one array per (position, t); it cannot serve fg_mask reads too") + if cache_volume and min_nonzero_fraction > 0: + # The check would also see transformed values when the cached volume is transformed once. + raise ValueError("cache_volume serves windows in order; min_nonzero_fraction retries random windows") + self.cache_volume = cache_volume + transforms = getattr(transform, "transforms", [transform]) + self._transform_volume = ( + cache_volume + and preloaded_fovs is None # preloaded windows bypass the cache + and bool(transform) # an empty Compose has nothing to apply + and all(getattr(t, "pointwise", False) for t in transforms) + ) + self._transform_windows = bool(transform) and not self._transform_volume + self._volume_key: tuple | None = None + self._volume: np.ndarray | None = None + if z_planes is not None and z_window_size != 1: + raise ValueError(f"z_planes selects single planes and needs z_window_size=1, got {z_window_size}") + self.z_planes = z_planes if not 0.0 <= min_nonzero_fraction <= 1.0: raise ValueError(f"min_nonzero_fraction must be in [0, 1], got {min_nonzero_fraction}") if max_nonzero_retries < 0: @@ -138,9 +203,35 @@ def _get_windows(self) -> None: if self.fg_mask_support is not None: self.fg_mask_support.validate_and_store(fov, img_arr, self.target_ch_idx) self._max_window = w + self._planned: list[tuple[int, int]] | None = None + if self.z_planes is not None: + self._planned = self._planned_windows() + self._max_window = len(self._planned) + + def _planned_windows(self) -> list[tuple[int, int]]: + """``(array index, window index)`` of every ``z_planes`` plane, in dataset order.""" + planned = [] + for arr_idx, img_arr in enumerate(self.window_arrays): + name = img_arr.path.rsplit("/", 1)[0] + if name not in self.z_planes: + raise KeyError(f"z_planes has no entry for position {name!r}") + per_t = self.z_planes[name] + if len(per_t) != img_arr.frames: + raise ValueError(f"z_planes[{name!r}] has {len(per_t)} timepoints; the array has {img_arr.frames}") + for t, planes in enumerate(per_t): + zs = sorted(set(int(z) for z in planes)) + if not zs or zs[0] < 0 or zs[-1] >= img_arr.slices: + raise ValueError( + f"z_planes[{name!r}][{t}] = {list(planes)} is empty or outside [0, {img_arr.slices})" + ) + planned.extend((arr_idx, t * img_arr.slices + z) for z in zs) + return planned def _find_window(self, index: int) -> tuple[ImageArray, int, NormMeta | None, int]: """Look up window given index.""" + if self._planned is not None: + arr_idx, tz = self._planned[index] + return (self.window_arrays[arr_idx], tz, self.window_norm_meta[arr_idx], arr_idx) arr_idx = bisect.bisect_right(self.window_keys, index) tz = index - self.window_keys[arr_idx - 1] if arr_idx > 0 else index return (self.window_arrays[arr_idx], tz, self.window_norm_meta[arr_idx], arr_idx) @@ -170,6 +261,7 @@ def _read_img_window( tz: int, arr_idx: int = -1, _preloaded: list[Tensor] | None = None, + as_float: bool = True, ) -> tuple[list[Tensor], HCSStackIndex]: """Read image window as tensor. @@ -188,6 +280,10 @@ def _read_img_window( _preloaded : list[Tensor] or None Override for ``self._preloaded``. When set, uses this list instead of the dataset-level preloaded data. + as_float : bool + Cast the window to float32 (images). When False, keep the stored + dtype (foreground masks: uint8 is 4x smaller in every worker + buffer and pinned host copy; the datamodule casts on GPU). Returns ------- @@ -200,15 +296,49 @@ def _read_img_window( z = tz - t * zs preloaded = _preloaded if _preloaded is not None else self._preloaded if preloaded is not None and arr_idx >= 0: - data = preloaded[arr_idx][t : t + 1, :, z : z + self.z_window_size].to(torch.float32, copy=True) + window = preloaded[arr_idx][t : t + 1, :, z : z + self.z_window_size] + data = window.to(torch.float32 if as_float else window.dtype, copy=True) return data.unbind(dim=1), (f"/{img.path}", t, z) + if self.cache_volume: + # Keyed on the array object: positions of different plates can share a path. + key = (id(img), t, tuple(ch_idx), as_float) + if self._volume_key != key: + # Release the previous volume first, so two never coexist; windows own copies. + self._volume, self._volume_key = None, None + # Per-channel basic slices, not oindex: the coordinate indexer peaks at ~7x + # the output size, which a whole volume makes large (see HCSDataModule's + # mmap preload). Filling one preallocated array keeps the peak at its size. + volume = np.empty((1, len(ch_idx), *img.shape[-3:]), dtype=np.float32 if as_float else img.dtype) + for j, c in enumerate(ch_idx): + volume[:, j] = img[t : t + 1, int(c)] + if self._transform_volume: + self._transform_cached(volume, arr_idx, t) + self._volume = volume + self._volume_key = key + data = self._volume[:, :, z : z + self.z_window_size] + if self._transform_windows: + # Copy: transforms must not reach the cached volume the next window is cut from. + data = data.copy() + return torch.from_numpy(data).unbind(dim=1), (f"/{img.path}", t, z) data = img.oindex[ slice(t, t + 1), [int(i) for i in ch_idx], slice(z, z + self.z_window_size), - ].astype(np.float32) + ] + if as_float: + data = data.astype(np.float32) return torch.from_numpy(data).unbind(dim=1), (f"/{img.path}", t, z) + def _transform_cached(self, volume: np.ndarray, arr_idx: int, t: int) -> None: + """Apply the pointwise transforms to a cached ``(1, C, Z, Y, X)`` volume in place.""" + images = {name: torch.from_numpy(volume[:, j]) for j, name in enumerate(self._all_ch_names)} + norm_meta = self._resolve_timepoint_norm_meta(self.window_norm_meta[arr_idx], t) + if norm_meta is not None: + images["norm_meta"] = norm_meta + images = self.transform(images) + for j, name in enumerate(self._all_ch_names): + volume[:, j] = np.asarray(images[name]) + def __len__(self) -> int: """Return total number of windows.""" return self._max_window @@ -269,7 +399,7 @@ def __getitem__(self, index: int) -> Sample: if norm_meta is not None: norm_meta = self._resolve_timepoint_norm_meta(norm_meta, sample_index[1]) sample_images["norm_meta"] = norm_meta - if self.transform: + if self._transform_windows: sample_images = self.transform(sample_images) if "weight" in sample_images: del sample_images["weight"] diff --git a/packages/viscy-data/tests/test_hcs.py b/packages/viscy-data/tests/test_hcs.py index 1242e1d81..72d487192 100644 --- a/packages/viscy-data/tests/test_hcs.py +++ b/packages/viscy-data/tests/test_hcs.py @@ -11,7 +11,7 @@ from viscy_data import HCSDataModule from viscy_data.sliding_window import SlidingWindowDataset -from viscy_transforms import BatchedRandFlipd, NormalizeSampled, RandSpatialCropd +from viscy_transforms import BatchedRandFlipd, MinMaxSampled, NormalizeSampled, RandSpatialCropd @mark.parametrize("multi_sample_augmentation", [True, False]) @@ -1061,7 +1061,7 @@ def test_mmap_preload_preserves_native_dtype_and_casts_on_read(tmp_path): def test_mmap_preload_fg_mask_preserves_native_dtype(hcs_with_fg_mask, tmp_path): - """fg_mask.mmap preserves native uint8 dtype; sampled masks cast to float32.""" + """fg_mask.mmap preserves native uint8 dtype, and so do the sampled masks.""" importorskip("tensordict") from tensordict.memmap import MemoryMappedTensor @@ -1093,7 +1093,50 @@ def test_mmap_preload_fg_mask_preserves_native_dtype(hcs_with_fg_mask, tmp_path) dm.setup(stage="fit") batch = next(iter(dm.train_dataloader())) - assert batch["fg_mask"].dtype == torch.float32 + assert batch["fg_mask"].dtype == torch.uint8 + + +@mark.parametrize("mmap_preload", [False, True]) +def test_fg_mask_stays_uint8_on_host_and_is_float_after_transfer(hcs_with_fg_mask, tmp_path, mmap_preload): + """Host-side fg_mask batches keep the stored uint8; the GPU hook casts to float32. + + Regression: masks were upcast to float32 in every sample, so full-FOV + validation batches carried a mask as large as the target through the + worker buffers and the power-of-two pinned-memory cache, and the 4-GPU + 3D seg-aux fits were OOM-killed at their first validation. + """ + if mmap_preload: + importorskip("tensordict") + from viscy_transforms import BatchedCenterSpatialCropd + + dm = HCSDataModule( + data_path=hcs_with_fg_mask, + source_channel="Phase", + target_channel="Fluorescence", + fg_mask_key="fg_mask", + z_window_size=4, + batch_size=2, + num_workers=0, + yx_patch_size=[16, 16], + split_ratio=0.5, + mmap_preload=mmap_preload, + scratch_dir=tmp_path, + val_gpu_augmentations=[BatchedCenterSpatialCropd(keys=["source", "target"], roi_size=[4, 16, 16])], + ) + dm.prepare_data() + dm.setup(stage="fit") + for loader in (dm.train_dataloader(), dm.val_dataloader()): + host = next(iter(loader)) + assert host["fg_mask"].dtype == torch.uint8 + assert host["fg_mask"].nbytes * 4 == host["target"].nbytes + assert set(host["fg_mask"].unique().tolist()).issubset({0, 1}) + + host_mask = host["fg_mask"].clone() + dm.trainer = MagicMock(training=False, validating=True, sanity_checking=False) + result = dm.on_after_batch_transfer(host, 0) + assert result["fg_mask"].dtype == torch.float32 + assert result["fg_mask"].shape == result["target"].shape == (2, 1, 4, 16, 16) + assert torch.equal(result["fg_mask"], host_mask[..., 8:24, 8:24].float()) @fixture(scope="function") @@ -1226,3 +1269,76 @@ def test_mmap_preload_matches_oindex(preprocessed_hcs_dataset, tmp_path): expected = np.asarray(pos["0"].oindex[:, ch_idx, :]) assert staged.shape == expected.shape np.testing.assert_array_equal(staged, expected) + + +class _WindowMeanCenter: + """Subtract each window's own mean: per-window statistics, so not pointwise.""" + + def __init__(self, key: str) -> None: + self.key = key + + def __call__(self, sample: dict) -> dict: + sample[self.key] = sample[self.key] - sample[self.key].mean() + return sample + + +@mark.parametrize("level", ["fov_statistics", "timepoint_statistics", "min_max", "per_window"]) +def test_cached_volume_transformed_once_equals_per_window_transforms(tmp_path, level): + """A pointwise normalization of the cached volume gives every window the bytes per-window normalization gives. + + Statistics differ per FOV and timepoint, so a volume normalized with another FOV's or frame's statistics shows. + A transform with per-window statistics is not pointwise and must keep running per window. + """ + path = tmp_path / "norm.zarr" + rng = np.random.default_rng(3) + with open_ome_zarr(path, layout="hcs", mode="w", channel_names=["Phase", "Fluorescence"]) as plate: + for i, fov in enumerate(("0", "1")): + pos = plate.create_position("A", "1", fov) + pos.create_image("0", (rng.normal(size=(2, 2, 7, 16, 16)) * 3 + 10).astype(np.float32)) + stats = [ + {"mean": 10.0 + i + 0.37 * t, "std": 2.9 + 0.11 * i - 0.05 * t, "p1": 5.0 + i, "p99": 15.0 - t} + for t in range(2) + ] + pos.zattrs["normalization"] = { + ch: {"fov_statistics": stats[0], "timepoint_statistics": {str(t): s for t, s in enumerate(stats)}} + for ch in ("Phase", "Fluorescence") + } + if level == "per_window": + transform = Compose([_WindowMeanCenter("Phase")]) + elif level == "min_max": + transform = Compose([MinMaxSampled(keys=["Phase"], level="timepoint_statistics")]) + else: + transform = Compose([NormalizeSampled(keys=["Phase", "Fluorescence"], level=level)]) + samples = {} + with open_ome_zarr(path, mode="r") as plate: + positions = [pos for _, pos in plate.positions()] + for cache_volume in (False, True): + dataset = SlidingWindowDataset( + positions=positions, + channels={"source": ["Phase"], "target": ["Fluorescence"]}, + z_window_size=4, + transform=transform, + cache_volume=cache_volume, + ) + assert dataset._transform_volume is (cache_volume and level != "per_window") + samples[cache_volume] = [dataset[i] for i in range(len(dataset))] + assert len(samples[True]) == 2 * 2 * 4 + for reference, cached in zip(samples[False], samples[True]): + assert reference["index"] == cached["index"] + for key in ("source", "target"): + assert reference[key].dtype == cached[key].dtype == torch.float32 + assert reference[key].numpy().tobytes() == cached[key].numpy().tobytes() + + +def test_cached_volume_refuses_nonzero_retries(hcs_with_fg_mask): + """Retries jump to random windows and would judge transformed values, so the volume cache refuses them.""" + with open_ome_zarr(hcs_with_fg_mask, mode="r") as ds: + positions = [pos for _, pos in ds.positions()] + with raises(ValueError, match="min_nonzero_fraction"): + SlidingWindowDataset( + positions=positions, + channels={"source": ["Phase"], "target": ["Fluorescence"]}, + z_window_size=4, + min_nonzero_fraction=0.1, + cache_volume=True, + ) From 879a8b2bc4eb18c066b16b9a96ace6d9a20a5041 Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:48:30 -0700 Subject: [PATCH 07/72] feat(viscy-models): per-axis CellDiff patches and mask-conditioning channels Port from dynacell-models: - patch_size may be a per-axis (z, y, x) tuple through the patch embedding, transformer unpatchify and ViT bottleneck, which lets CELLDiffNet run Z-preserving at Z=1 for the 2D track (an int is still accepted); - CELLDiffNet(cond_channels=1) adds extra conditioning input channels (default keeps the old single-channel net). Source on dynacell-models: 0126fe6f, 0617ed71, 40de7939 (#498). Co-Authored-By: Claude Opus 5.5 --- .../viscy_models/celldiff/celldiff_2d_test.py | 82 +++++++++++++++++++ .../src/viscy_models/celldiff/celldiff_net.py | 27 ++++-- .../celldiff/modules/patch_embed_3d.py | 41 ++++++++-- .../celldiff/modules/transformer.py | 30 ++++--- .../src/viscy_models/celldiff/unet_vit_3d.py | 10 ++- .../viscy_models/celldiff/vit_bottleneck.py | 31 ++++--- .../tests/test_celldiff/test_celldiff_net.py | 2 +- .../tests/test_celldiff/test_unet_vit_3d.py | 2 +- 8 files changed, 184 insertions(+), 41 deletions(-) create mode 100644 packages/viscy-models/src/viscy_models/celldiff/celldiff_2d_test.py diff --git a/packages/viscy-models/src/viscy_models/celldiff/celldiff_2d_test.py b/packages/viscy-models/src/viscy_models/celldiff/celldiff_2d_test.py new file mode 100644 index 000000000..1a9767455 --- /dev/null +++ b/packages/viscy-models/src/viscy_models/celldiff/celldiff_2d_test.py @@ -0,0 +1,82 @@ +"""CELLDiffNet at Z=1 with a per-axis patch (the CellDiff-2D configuration).""" + +import pytest +import torch + +from viscy_models.celldiff.celldiff_net import CELLDiffNet +from viscy_models.celldiff.modules.patch_embed_3d import normalize_patch_size + +#: Small enough to build and run on CPU in a test; same topology as the recipe. +_NET_KWARGS = dict( + in_channels=1, + dims=[8, 16, 32, 32], + num_res_block=[2, 2, 2], + hidden_size=64, + num_heads=4, + dim_head=16, + num_hidden_layers=1, +) + + +def test_normalize_patch_size_expands_int_and_validates() -> None: + """An int stays cubic; a triple passes through; anything else raises.""" + assert normalize_patch_size(4) == (4, 4, 4) + assert normalize_patch_size([1, 4, 4]) == (1, 4, 4) + assert normalize_patch_size((2, 3, 4)) == (2, 3, 4) + for bad in (0, -1, [1, 4], [0, 4, 4], [1, 4, 4, 4]): + with pytest.raises(ValueError): + normalize_patch_size(bad) + + +@pytest.mark.parametrize( + ("spatial", "patch"), + [([1, 64, 64], [1, 4, 4]), ([1, 32, 32], [1, 2, 2]), ([8, 64, 64], 4)], +) +def test_celldiff_net_roundtrips_spatial_shape(spatial: list[int], patch: int | list[int]) -> None: + """Z=1 with a (1, p, p) patch runs, and the cubic 3D path is unchanged.""" + net = CELLDiffNet(input_spatial_size=spatial, patch_size=patch, **_NET_KWARGS) + x = torch.randn(2, 1, *spatial) + out = net(x, cond=torch.randn(2, 1, *spatial), t=torch.rand(2)) + assert out.shape == (2, 1, *spatial) + assert torch.isfinite(out).all() + + +def test_celldiff_net_z1_backward_reaches_every_parameter() -> None: + """A frozen/disconnected patch path would silently starve gradients at Z=1.""" + spatial = [1, 64, 64] + net = CELLDiffNet(input_spatial_size=spatial, patch_size=[1, 4, 4], **_NET_KWARGS) + out = net(torch.randn(1, 1, *spatial), cond=torch.randn(1, 1, *spatial), t=torch.rand(1)) + out.square().mean().backward() + starved = [ + name + for name, p in net.named_parameters() + if p.requires_grad and (p.grad is None or not torch.isfinite(p.grad).all()) + ] + assert not starved, f"parameters with missing/non-finite grads: {starved[:5]}" + + +def test_cubic_patch_is_rejected_at_z1() -> None: + """The failure that motivated per-axis patches must stay a loud error.""" + with pytest.raises(ValueError, match="not divisible by its patch extent"): + CELLDiffNet(input_spatial_size=[1, 64, 64], patch_size=4, **_NET_KWARGS) + + +def test_z1_patch_grid_drops_the_z_axis() -> None: + """The token grid must be (1, H/2**n/p, W/2**n/p) — no phantom Z tokens.""" + net = CELLDiffNet(input_spatial_size=[1, 64, 64], patch_size=[1, 4, 4], **_NET_KWARGS) + # 3 downsamples of stride (1, 2, 2): 64 -> 8, then patch 4 -> 2 + assert net.bottleneck.latent_grid_size == [1, 2, 2] + assert net.bottleneck.img_pos_embed.shape[1] == 4 + + +def test_cond_channels_widens_the_conditioning_conv_only() -> None: + """Extra conditioning channels (C-cond) are accepted and every other shape is unchanged.""" + spatial = [1, 32, 32] + base = CELLDiffNet(input_spatial_size=spatial, patch_size=[1, 4, 4], **_NET_KWARGS) + net = CELLDiffNet(input_spatial_size=spatial, patch_size=[1, 4, 4], cond_channels=2, **_NET_KWARGS) + widened = {name for name, p in net.state_dict().items() if p.shape != base.state_dict()[name].shape} + assert widened == {"_cond_inconv.weight"} + out = net(torch.randn(2, 1, *spatial), cond=torch.randn(2, 2, *spatial), t=torch.rand(2)) + assert out.shape == (2, 1, *spatial) + with pytest.raises(ValueError, match="cond must have 2 channel"): + net(torch.randn(2, 1, *spatial), cond=torch.randn(2, 1, *spatial), t=torch.rand(2)) diff --git a/packages/viscy-models/src/viscy_models/celldiff/celldiff_net.py b/packages/viscy-models/src/viscy_models/celldiff/celldiff_net.py index 537cdc360..b478e279b 100644 --- a/packages/viscy-models/src/viscy_models/celldiff/celldiff_net.py +++ b/packages/viscy-models/src/viscy_models/celldiff/celldiff_net.py @@ -9,6 +9,8 @@ application layer and is not part of this package. """ +from collections.abc import Sequence + import torch from torch import Tensor @@ -51,8 +53,14 @@ class CELLDiffNet(UNet3DBase): Feed-forward output dropout rate. num_hidden_layers : int Number of transformer blocks in the bottleneck. - patch_size : int - Cubic patch size for the 3D patch embedding. + patch_size : int | Sequence[int] + Cubic patch size for the 3D patch embedding, or per-axis + ``(D, H, W)`` extents. Use ``(1, p, p)`` at ``D=1`` for the + Z-preserving 2D configuration. + cond_channels : int + Number of conditioning channels, fused additively with the noisy + target after the first convolution. ``1`` is phase alone; extra + channels carry further pixel-aligned conditions (e.g. a mask). """ def __init__( @@ -67,8 +75,11 @@ def __init__( dropout: float = 0.0, final_dropout: float = 0.0, num_hidden_layers: int = 2, - patch_size: int = 4, + patch_size: int | Sequence[int] = 4, + cond_channels: int = 1, ) -> None: + if cond_channels < 1: + raise ValueError(f"cond_channels must be >= 1, got {cond_channels}") if input_spatial_size is None: input_spatial_size = [8, 512, 512] if dims is None: @@ -97,9 +108,10 @@ def __init__( bottleneck=bottleneck, downsample_z=False, time_embed_dim=hidden_size, - cond_channels=1, + cond_channels=cond_channels, ) self.input_spatial_size = input_spatial_size + self.cond_channels = cond_channels def forward(self, x: Tensor, cond: Tensor, t: Tensor) -> Tensor: """Predict velocity field for flow-matching. @@ -109,7 +121,8 @@ def forward(self, x: Tensor, cond: Tensor, t: Tensor) -> Tensor: x : Tensor Noisy target volume of shape ``(B, in_channels, D, H, W)``. cond : Tensor - Phase contrast conditioning of shape ``(B, 1, D, H, W)``. + Conditioning of shape ``(B, cond_channels, D, H, W)``; channel 0 + is phase. t : Tensor Diffusion timesteps of shape ``(B,)``. @@ -124,6 +137,6 @@ def forward(self, x: Tensor, cond: Tensor, t: Tensor) -> Tensor: raise ValueError( f"cond spatial size {list(cond.shape[2:])} does not match expected {self.input_spatial_size}" ) - if cond.shape[1] != 1: - raise ValueError(f"cond must have 1 channel, got {cond.shape[1]}") + if cond.shape[1] != self.cond_channels: + raise ValueError(f"cond must have {self.cond_channels} channel(s), got {cond.shape[1]}") return super().forward(x, cond=cond, t=t) diff --git a/packages/viscy-models/src/viscy_models/celldiff/modules/patch_embed_3d.py b/packages/viscy-models/src/viscy_models/celldiff/modules/patch_embed_3d.py index 507a6f3f2..7a01d6a64 100644 --- a/packages/viscy-models/src/viscy_models/celldiff/modules/patch_embed_3d.py +++ b/packages/viscy-models/src/viscy_models/celldiff/modules/patch_embed_3d.py @@ -1,19 +1,49 @@ """3D patch embedding for vision transformers.""" +from collections.abc import Sequence + import torch import torch.nn as nn +__all__ = ["PatchEmbed3D", "normalize_patch_size"] + + +def normalize_patch_size(patch_size: int | Sequence[int]) -> tuple[int, int, int]: + """Expand a patch size to a per-axis ``(D, H, W)`` triple. + + An ``int`` means a cubic patch, matching the original CELL-Diff recipe. A + 3-sequence gives per-axis control, which is what lets the same network run + Z-preserving at ``D=1`` — a cubic ``patch_size=4`` would need a Conv3d with + a size-4 kernel over a size-1 axis. + + Parameters + ---------- + patch_size : int | Sequence[int] + Cubic side length, or ``(D, H, W)`` patch extents. + + Returns + ------- + tuple[int, int, int] + Per-axis patch extents. + """ + dims = (patch_size,) * 3 if isinstance(patch_size, int) else tuple(int(p) for p in patch_size) + if len(dims) != 3: + raise ValueError(f"patch_size must be an int or a length-3 sequence, got {patch_size!r}") + if any(p < 1 for p in dims): + raise ValueError(f"patch_size entries must be >= 1, got {patch_size!r}") + return dims + class PatchEmbed3D(nn.Module): """Convert a 3D volume into a sequence of patch embeddings. Uses a single strided 3D convolution to project non-overlapping - cubic patches into an embedding space. + patches into an embedding space. Parameters ---------- - patch_size : int - Cubic patch side length. + patch_size : int | Sequence[int] + Cubic patch side length, or per-axis ``(D, H, W)`` extents. in_chans : int Number of input channels. embed_dim : int @@ -22,9 +52,10 @@ class PatchEmbed3D(nn.Module): Whether to include bias in the projection convolution. """ - def __init__(self, patch_size: int, in_chans: int, embed_dim: int, bias: bool = True) -> None: + def __init__(self, patch_size: int | Sequence[int], in_chans: int, embed_dim: int, bias: bool = True) -> None: super().__init__() - self.proj = nn.Conv3d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size, bias=bias) + patch = normalize_patch_size(patch_size) + self.proj = nn.Conv3d(in_chans, embed_dim, kernel_size=patch, stride=patch, bias=bias) def forward(self, x: torch.Tensor) -> torch.Tensor: """Project input volume into patch token sequence. diff --git a/packages/viscy-models/src/viscy_models/celldiff/modules/transformer.py b/packages/viscy-models/src/viscy_models/celldiff/modules/transformer.py index 40e096704..2d4211c35 100644 --- a/packages/viscy-models/src/viscy_models/celldiff/modules/transformer.py +++ b/packages/viscy-models/src/viscy_models/celldiff/modules/transformer.py @@ -1,10 +1,14 @@ """Transformer blocks and output layers for CellDiff models.""" +from collections.abc import Sequence + import torch import torch.nn as nn from diffusers.models.attention import FeedForward from diffusers.models.attention_processor import Attention +from viscy_models.celldiff.modules.patch_embed_3d import normalize_patch_size + def modulate(x: torch.Tensor, shift: torch.Tensor, scale: torch.Tensor) -> torch.Tensor: """Apply adaptive layer norm modulation: ``x * (1 + scale) + shift``.""" @@ -151,35 +155,35 @@ def unpatchify( x: torch.Tensor, out_channels: int, latent_grid_size: list[int], - patch_size: int, + patch_size: int | Sequence[int], ) -> torch.Tensor: """Reconstruct a 3D volume from patch tokens. Parameters ---------- x : torch.Tensor - Patch tokens of shape ``(N, T, patch_size**3 * out_channels)``. + Patch tokens of shape ``(N, T, prod(patch_size) * out_channels)``. out_channels : int Number of output channels. latent_grid_size : list[int] Latent grid dimensions ``[D, H, W]`` such that ``D*H*W == T``. - patch_size : int - Cubic patch side length. + patch_size : int | Sequence[int] + Cubic patch side length, or per-axis ``(D, H, W)`` extents. Returns ------- torch.Tensor - Reconstructed volume of shape ``(N, out_channels, D*p, H*p, W*p)``. + Reconstructed volume of shape ``(N, out_channels, D*pd, H*ph, W*pw)``. """ c = out_channels - p = patch_size + pd, ph, pw = normalize_patch_size(patch_size) d, h, w = latent_grid_size if d * h * w != x.shape[1]: raise ValueError(f"Expected {d * h * w} tokens (grid {d}x{h}x{w}), got {x.shape[1]}") - x = x.reshape(x.shape[0], d, h, w, p, p, p, c) + x = x.reshape(x.shape[0], d, h, w, pd, ph, pw, c) x = x.permute(0, 7, 1, 4, 2, 5, 3, 6) - imgs = x.reshape(x.shape[0], c, d * p, h * p, w * p) + imgs = x.reshape(x.shape[0], c, d * pd, h * ph, w * pw) return imgs @@ -190,8 +194,9 @@ class FinalLayer(nn.Module): ---------- hidden_size : int Transformer hidden dimension. - patch_size : int - Cubic patch size (output is ``patch_size**3 * out_channels`` per token). + patch_size : int | Sequence[int] + Cubic patch size, or per-axis ``(D, H, W)`` extents (output is + ``prod(patch_size) * out_channels`` per token). out_channels : int Number of output channels after unpatchifying. time_embed_dim : int | None @@ -202,13 +207,14 @@ class FinalLayer(nn.Module): def __init__( self, hidden_size: int, - patch_size: int, + patch_size: int | Sequence[int], out_channels: int, time_embed_dim: int | None = None, ) -> None: super().__init__() + pd, ph, pw = normalize_patch_size(patch_size) self.norm_final = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6) - self.linear = nn.Linear(hidden_size, patch_size * patch_size * patch_size * out_channels, bias=True) + self.linear = nn.Linear(hidden_size, pd * ph * pw * out_channels, bias=True) if time_embed_dim is not None: self.adaLN = nn.Sequential( nn.SiLU(), diff --git a/packages/viscy-models/src/viscy_models/celldiff/unet_vit_3d.py b/packages/viscy-models/src/viscy_models/celldiff/unet_vit_3d.py index 301f0d168..9f115b903 100644 --- a/packages/viscy-models/src/viscy_models/celldiff/unet_vit_3d.py +++ b/packages/viscy-models/src/viscy_models/celldiff/unet_vit_3d.py @@ -5,6 +5,8 @@ transformer bottleneck, CNN decoder with skip connections. """ +from collections.abc import Sequence + import torch from torch import Tensor @@ -50,8 +52,10 @@ class UNetViT3D(UNet3DBase): Feed-forward output dropout rate. num_hidden_layers : int Number of transformer blocks in the bottleneck. - patch_size : int - Cubic patch size for the 3D patch embedding. + patch_size : int | Sequence[int] + Cubic patch size for the 3D patch embedding, or per-axis + ``(D, H, W)`` extents. Use ``(1, p, p)`` at ``D=1`` for the + Z-preserving 2D configuration. """ def __init__( @@ -67,7 +71,7 @@ def __init__( dropout: float = 0.0, final_dropout: float = 0.0, num_hidden_layers: int = 2, - patch_size: int = 4, + patch_size: int | Sequence[int] = 4, ) -> None: if input_spatial_size is None: input_spatial_size = [8, 512, 512] diff --git a/packages/viscy-models/src/viscy_models/celldiff/vit_bottleneck.py b/packages/viscy-models/src/viscy_models/celldiff/vit_bottleneck.py index 6d4fc6e9f..c92f03cbe 100644 --- a/packages/viscy-models/src/viscy_models/celldiff/vit_bottleneck.py +++ b/packages/viscy-models/src/viscy_models/celldiff/vit_bottleneck.py @@ -8,11 +8,13 @@ Requires ``diffusers`` (for Attention and FeedForward). """ +from collections.abc import Sequence + import torch import torch.nn as nn from torch import Tensor -from viscy_models.celldiff.modules.patch_embed_3d import PatchEmbed3D +from viscy_models.celldiff.modules.patch_embed_3d import PatchEmbed3D, normalize_patch_size from viscy_models.celldiff.modules.positional_embedding import get_3d_sincos_pos_embed from viscy_models.celldiff.modules.transformer import ( FinalLayer, @@ -52,8 +54,10 @@ class ViTBottleneck3D(nn.Module): Feed-forward output dropout rate. num_hidden_layers : int Number of transformer blocks. - patch_size : int - Cubic patch size for the 3D patch embedding. + patch_size : int | Sequence[int] + Cubic patch size for the 3D patch embedding, or per-axis + ``(D, H, W)`` extents. Use ``(1, p, p)`` for a Z-preserving 2D + configuration at ``D=1``. time_embed_dim : int | None Timestep embedding dimension for adaLN-Zero conditioning. Pass None for unconditional (deterministic) models. @@ -71,13 +75,13 @@ def __init__( dropout: float = 0.0, final_dropout: float = 0.0, num_hidden_layers: int = 2, - patch_size: int = 4, + patch_size: int | Sequence[int] = 4, time_embed_dim: int | None = None, ) -> None: super().__init__() self._in_channels = in_channels - self._patch_size = patch_size + self._patch_size = normalize_patch_size(patch_size) # ── Compute latent spatial size after encoder downsamples ──────── # Stride-2 convolutions require exact divisibility; floor division @@ -98,20 +102,23 @@ def __init__( latent_size = input_spatial_size[:1] + [s // factor for s in input_spatial_size[1:]] # ── Validate patch divisibility ───────────────────────────────── - for dim_val, name, orig in zip(latent_size, dim_names, input_spatial_size): - if dim_val % patch_size != 0: + # Checked per axis: a Z-preserving 2D configuration runs D=1 with a + # patch of (1, p, p), where a cubic p would be neither divisible nor + # convolvable. + for dim_val, name, orig, p in zip(latent_size, dim_names, input_spatial_size, self._patch_size): + if dim_val % p != 0: raise ValueError( f"Latent {name} dimension {dim_val} (from input {name}={orig}) " - f"is not divisible by patch_size={patch_size}. " + f"is not divisible by its patch extent {p} (patch_size={patch_size}). " f"Each spatial dimension after {num_downsamples} encoder downsamples " - f"must be divisible by patch_size." + f"must be divisible by the patch extent on that axis." ) - self.latent_grid_size = [s // patch_size for s in latent_size] + self.latent_grid_size = [s // p for s, p in zip(latent_size, self._patch_size)] # ── Patch embedding ───────────────────────────────────────────── self.img_embedding = PatchEmbed3D( - patch_size=patch_size, + patch_size=self._patch_size, in_chans=in_channels, embed_dim=hidden_size, bias=True, @@ -141,7 +148,7 @@ def __init__( # ── Output projection ─────────────────────────────────────────── self.proj_out = FinalLayer( hidden_size=hidden_size, - patch_size=patch_size, + patch_size=self._patch_size, out_channels=in_channels, time_embed_dim=time_embed_dim, ) diff --git a/packages/viscy-models/tests/test_celldiff/test_celldiff_net.py b/packages/viscy-models/tests/test_celldiff/test_celldiff_net.py index 225150911..8b84c9c1b 100644 --- a/packages/viscy-models/tests/test_celldiff/test_celldiff_net.py +++ b/packages/viscy-models/tests/test_celldiff/test_celldiff_net.py @@ -56,5 +56,5 @@ def test_wrong_cond_channels_raises(small_config): def test_indivisible_patch_size_raises(small_config): """Constructor rejects spatial sizes not divisible by patch_size after downsampling.""" - with pytest.raises(ValueError, match="not divisible by patch_size"): + with pytest.raises(ValueError, match="not divisible by its patch extent"): CELLDiffNet(**{**small_config, "input_spatial_size": [10, 64, 64]}) diff --git a/packages/viscy-models/tests/test_celldiff/test_unet_vit_3d.py b/packages/viscy-models/tests/test_celldiff/test_unet_vit_3d.py index 3260305bc..be65bc242 100644 --- a/packages/viscy-models/tests/test_celldiff/test_unet_vit_3d.py +++ b/packages/viscy-models/tests/test_celldiff/test_unet_vit_3d.py @@ -52,5 +52,5 @@ def test_wrong_spatial_raises(small_config): def test_indivisible_patch_size_raises(small_config): """Constructor rejects spatial sizes not divisible by patch_size after downsampling.""" # D=10: after 2 downsamples at stride (1,2,2), latent D=10, not divisible by patch_size=4 - with pytest.raises(ValueError, match="not divisible by patch_size"): + with pytest.raises(ValueError, match="not divisible by its patch extent"): UNetViT3D(**{**small_config, "input_spatial_size": [10, 64, 64]}) From 0d3e690f5adf07010842d03c60ef551b5d484ca8 Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:48:40 -0700 Subject: [PATCH 08/72] perf(viscy-models): non-uniform ODE time grids for CellDiff sampling Port the time_schedule option of the CellDiff ODE integrators from dynacell-models: uniform (default, unchanged), cosine, or a Beta(p, q) grid packed toward the data end, which is what lets the DynaCell-lite recipe sample in 14 velocity evaluations. scipy joins the celldiff extra for betaincinv. Source on dynacell-models: 19765e71 (#520). Co-Authored-By: Claude Opus 5.5 --- packages/viscy-models/pyproject.toml | 2 +- .../celldiff/modules/transport/integrators.py | 37 +++++++++- .../celldiff/modules/transport/transport.py | 7 ++ .../tests/test_celldiff/test_transport.py | 73 +++++++++++++++++++ 4 files changed, 115 insertions(+), 4 deletions(-) diff --git a/packages/viscy-models/pyproject.toml b/packages/viscy-models/pyproject.toml index 9a71806d9..fe563943e 100644 --- a/packages/viscy-models/pyproject.toml +++ b/packages/viscy-models/pyproject.toml @@ -39,7 +39,7 @@ dependencies = [ "transformers>=4.40", ] -optional-dependencies.celldiff = [ "diffusers", "torchdiffeq" ] +optional-dependencies.celldiff = [ "diffusers", "scipy", "torchdiffeq" ] urls.Homepage = "https://github.com/mehta-lab/VisCy" urls.Issues = "https://github.com/mehta-lab/VisCy/issues" diff --git a/packages/viscy-models/src/viscy_models/celldiff/modules/transport/integrators.py b/packages/viscy-models/src/viscy_models/celldiff/modules/transport/integrators.py index db3962d28..6e16e1917 100644 --- a/packages/viscy-models/src/viscy_models/celldiff/modules/transport/integrators.py +++ b/packages/viscy-models/src/viscy_models/celldiff/modules/transport/integrators.py @@ -6,7 +6,9 @@ from collections.abc import Callable +import numpy as np import torch +from scipy.special import betaincinv from torch import Tensor from torchdiffeq import odeint @@ -143,12 +145,20 @@ class ODESolver: sampler_type : str ODE solver method (e.g. ``"dopri5"``, ``"euler"``). num_steps : int - Number of time points (for fixed-step methods, this is the step count; - for adaptive methods, this controls the output grid). + Number of time points (for fixed-step methods, the solver takes + ``num_steps - 1`` steps on them; for adaptive methods, this controls + the output grid). atol : float Absolute error tolerance. rtol : float Relative error tolerance. + time_schedule : str or tuple of float + ``"uniform"`` (linearly spaced time points), ``"cosine"`` + (``t0 + (t1 - t0) * (1 - cos(pi * s)) / 2`` over uniform ``s``, which + clusters the points at both ends of the interval), or ``(p, q)``: the + Beta(p, q) quantiles of uniform ``s``. Cosine is Beta(0.5, 0.5) and + uniform is Beta(1, 1); ``p`` or ``q`` below 1 packs the points toward + ``t0`` or ``t1``. """ def __init__( @@ -161,11 +171,32 @@ def __init__( num_steps: int, atol: float, rtol: float, + time_schedule: str | tuple[float, float] = "uniform", ) -> None: if t0 >= t1: raise ValueError("ODE solver requires t0 < t1") self.drift = drift - self.t = torch.linspace(t0, t1, num_steps) + if time_schedule == "uniform": + self.t = torch.linspace(t0, t1, num_steps) + elif time_schedule == "cosine": + s = torch.linspace(0.0, 1.0, num_steps, dtype=torch.float64) + self.t = (t0 + (t1 - t0) * (1 - torch.cos(torch.pi * s)) / 2).float() + elif ( + isinstance(time_schedule, tuple | list) + and len(time_schedule) == 2 + and all(0 < v < np.inf for v in time_schedule) + ): + p, q = time_schedule + self.t = torch.from_numpy(t0 + (t1 - t0) * betaincinv(p, q, np.linspace(0.0, 1.0, num_steps))).float() + else: + raise ValueError( + f"time_schedule must be 'uniform', 'cosine' or finite positive (p, q), got {time_schedule!r}" + ) + if not bool((self.t.diff() > 0).all()): + raise ValueError( + f"time_schedule {time_schedule!r} puts {num_steps} time points on [{t0}, {t1}] that are not" + " strictly increasing in float32; use fewer points or a less extreme shape" + ) self.atol = atol self.rtol = rtol self.sampler_type = sampler_type diff --git a/packages/viscy-models/src/viscy_models/celldiff/modules/transport/transport.py b/packages/viscy-models/src/viscy_models/celldiff/modules/transport/transport.py index 24eefbcbd..961a58411 100644 --- a/packages/viscy-models/src/viscy_models/celldiff/modules/transport/transport.py +++ b/packages/viscy-models/src/viscy_models/celldiff/modules/transport/transport.py @@ -450,6 +450,7 @@ def sample_ode( atol: float = 1e-6, rtol: float = 1e-3, reverse: bool = False, + time_schedule: str | tuple[float, float] = "uniform", ) -> Callable: """Return an ODE sampling function. @@ -465,6 +466,11 @@ def sample_ode( Relative error tolerance. reverse : bool Whether to integrate in reverse (data to noise). + time_schedule : str or tuple of float + Spacing of the ``num_steps`` time points: ``"uniform"``, + ``"cosine"`` (``(1 - cos(pi * s)) / 2`` over uniform ``s``, dense at + both ends of the interval) or ``(p, q)`` for Beta(p, q) quantiles + (see :class:`ODESolver`). Fixed-grid solvers step on these points. Returns ------- @@ -496,6 +502,7 @@ def drift(x, t, model, **kwargs): num_steps=num_steps, atol=atol, rtol=rtol, + time_schedule=time_schedule, ) return _ode.sample diff --git a/packages/viscy-models/tests/test_celldiff/test_transport.py b/packages/viscy-models/tests/test_celldiff/test_transport.py index d92fa635b..0c7e35b0d 100644 --- a/packages/viscy-models/tests/test_celldiff/test_transport.py +++ b/packages/viscy-models/tests/test_celldiff/test_transport.py @@ -110,3 +110,76 @@ def dummy_model(x, t): # Result is a trajectory tensor from odeint. assert result.shape[0] == 5 assert result.shape[1:] == x_init.shape + + +def test_ode_solver_cosine_schedule_packs_points_at_both_ends(): + """The cosine grid keeps the endpoints and spaces points densest next to t0 and t1.""" + kwargs = dict(drift=lambda x, t, model: x, t0=0.0, t1=1.0, sampler_type="euler", num_steps=9, atol=1e-5, rtol=1e-3) + uniform = ODESolver(**kwargs).t + cosine = ODESolver(**kwargs, time_schedule="cosine").t + torch.testing.assert_close(uniform, torch.linspace(0, 1, 9)) + assert cosine[0] == 0.0 and cosine[-1] == 1.0 + gaps = cosine.diff() + assert gaps[0] < gaps[4] and gaps[-1] < gaps[4] + torch.testing.assert_close(gaps, gaps.flip(0)) + + +def test_ode_solver_beta_schedule_spans_cosine_and_uniform(): + """Beta(0.5, 0.5) is the cosine grid, Beta(1, 1) the uniform one, and p < q packs points toward t0.""" + kwargs = dict(drift=lambda x, t, model: x, t0=0.0, t1=1.0, sampler_type="euler", num_steps=8, atol=1e-5, rtol=1e-3) + torch.testing.assert_close( + ODESolver(**kwargs, time_schedule=(0.5, 0.5)).t, ODESolver(**kwargs, time_schedule="cosine").t + ) + torch.testing.assert_close(ODESolver(**kwargs, time_schedule=(1.0, 1.0)).t, ODESolver(**kwargs).t) + skewed = ODESolver(**kwargs, time_schedule=(0.3, 0.6)).t + assert skewed[0] == 0.0 and skewed[-1] == 1.0 + gaps = skewed.diff() + assert (gaps > 0).all() and gaps[0] < gaps[-1] + inner = ODESolver(**{**kwargs, "t0": 0.1, "t1": 0.9}, time_schedule=(0.3, 0.6)).t + torch.testing.assert_close(inner, 0.1 + 0.8 * skewed) + + +def test_ode_solver_rejects_a_beta_grid_that_collapses_in_float32(): + """Beta(1, 0.1) at 8 points puts its last two quantiles within float32 rounding of 1.0, which odeint + would only reject mid-predict.""" + with pytest.raises(ValueError, match="strictly increasing"): + ODESolver( + drift=lambda x, t, model: x, + t0=0.0, + t1=1.0, + sampler_type="euler", + num_steps=8, + atol=1e-5, + rtol=1e-3, + time_schedule=(1.0, 0.1), + ) + + +@pytest.mark.parametrize("schedule", ["cos", (0.0, 0.5), (0.5,), (0.5, float("nan")), (0.5, float("inf"))]) +def test_ode_solver_rejects_unknown_schedule(schedule): + """A misspelled schedule or a non-positive or non-finite Beta shape raises instead of building a bad grid.""" + with pytest.raises(ValueError, match="time_schedule"): + ODESolver( + drift=lambda x, t, model: x, + t0=0.0, + t1=1.0, + sampler_type="euler", + num_steps=5, + atol=1e-5, + rtol=1e-3, + time_schedule=schedule, + ) + + +def test_sampler_euler_with_cosine_schedule_steps_on_the_grid(): + """A fixed-grid sampler evaluates the drift once per step, at the cosine grid's left points.""" + sampler = Sampler(create_transport()) + seen = [] + + def model(x, t): + seen.append(float(t[0])) + return torch.zeros_like(x) + + sampler.sample_ode(sampling_method="euler", num_steps=5, time_schedule="cosine")(torch.randn(1, 1, 2, 2, 2), model) + expected = (1 - torch.cos(torch.pi * torch.linspace(0, 1, 5, dtype=torch.float64))) / 2 + assert seen == pytest.approx(expected[:-1].tolist(), abs=1e-6) From 859f9905f7b2dde863b68c42821481c54f9859af Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:48:42 -0700 Subject: [PATCH 09/72] feat(viscy-models): add the MorphEm feature extractor Port MorphEmModel from dynacell-models, the fifth deep-feature extractor of the DynaCell evaluation. transformers is imported lazily and the trust_remote_code model is pinned to a Hub commit. Source on dynacell-models: d3f6422f (#479), 4918d2ee, 13cb3363, c9c69141. Co-Authored-By: Claude Opus 5.5 --- .../viscy-models/src/viscy_models/__init__.py | 3 +- .../src/viscy_models/foundation/__init__.py | 3 +- .../src/viscy_models/foundation/morphem.py | 160 ++++++++++++++++++ .../tests/test_foundation/test_morphem.py | 110 ++++++++++++ 4 files changed, 274 insertions(+), 2 deletions(-) create mode 100644 packages/viscy-models/src/viscy_models/foundation/morphem.py create mode 100644 packages/viscy-models/tests/test_foundation/test_morphem.py diff --git a/packages/viscy-models/src/viscy_models/__init__.py b/packages/viscy-models/src/viscy_models/__init__.py index 436054985..0b66cee5a 100644 --- a/packages/viscy-models/src/viscy_models/__init__.py +++ b/packages/viscy-models/src/viscy_models/__init__.py @@ -6,7 +6,7 @@ from viscy_models.components.heads import MLP, CosineClassifier from viscy_models.contrastive import ContrastiveEncoder, NTXentHCL, ResNet3dEncoder -from viscy_models.foundation import DINOv3Model, OpenPhenomModel +from viscy_models.foundation import DINOv3Model, MorphEmModel, OpenPhenomModel from viscy_models.unet import FullyConvolutionalMAE, Unet2d, Unet3d, Unet25d, UNeXt2 from viscy_models.vae import BetaVae25D, BetaVaeMonai @@ -16,6 +16,7 @@ "ContrastiveEncoder", "CosineClassifier", "DINOv3Model", + "MorphEmModel", "NTXentHCL", "OpenPhenomModel", "FullyConvolutionalMAE", diff --git a/packages/viscy-models/src/viscy_models/foundation/__init__.py b/packages/viscy-models/src/viscy_models/foundation/__init__.py index 12f1da3ee..fa52ba881 100644 --- a/packages/viscy-models/src/viscy_models/foundation/__init__.py +++ b/packages/viscy-models/src/viscy_models/foundation/__init__.py @@ -2,6 +2,7 @@ from viscy_models.foundation.cell_dino import CellDinoModel from viscy_models.foundation.dinov3 import DINOv3Model +from viscy_models.foundation.morphem import MorphEmModel from viscy_models.foundation.openphenom import OpenPhenomModel -__all__ = ["CellDinoModel", "DINOv3Model", "OpenPhenomModel"] +__all__ = ["CellDinoModel", "DINOv3Model", "MorphEmModel", "OpenPhenomModel"] diff --git a/packages/viscy-models/src/viscy_models/foundation/morphem.py b/packages/viscy-models/src/viscy_models/foundation/morphem.py new file mode 100644 index 000000000..f94cfe253 --- /dev/null +++ b/packages/viscy-models/src/viscy_models/foundation/morphem.py @@ -0,0 +1,160 @@ +"""MorphEm foundation model wrapper for frozen feature extraction.""" + +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch import Tensor + + +class MorphEmModel(nn.Module): + """Wrap CaicedoLab/MorphEm (DINO-pretrained ViT-S/16 on microscopy). + + MorphEm is a single-channel ViT: each microscopy channel is encoded + independently and the CLS tokens are reduced to a fixed embedding. + :meth:`preprocess_2d` handles Z-squeeze, resize to 224, and per-image + per-channel spatial z-score (the published ``PerImageNormalize`` recipe). + + Parameters + ---------- + model_name : str + HuggingFace id (``"CaicedoLab/MorphEm"``) or a local snapshot dir. + revision : str | None + Hub commit SHA (or tag) to load. MorphEm ships its ViT as + ``trust_remote_code`` Python, so an unpinned id would execute + whatever is at the repository head on a cache miss. Ignored for a + local snapshot dir. + img_size : int + Spatial size inputs are resized to, by default 224. + freeze : bool + If ``True`` (default), backbone params are frozen and kept in eval mode. + projection : nn.Module | None + Optional projection head applied to the pooled embedding. + """ + + def __init__( + self, + model_name: str, + revision: str | None = None, + img_size: int = 224, + freeze: bool = True, + projection: nn.Module | None = None, + ) -> None: + super().__init__() + + import transformers + from transformers import AutoModel + + # transformers 5.x compatibility shim. MorphEm's trust_remote_code + # VisionTransformer (authored against transformers 4.x) + # never sets `all_tied_weights_keys`, which 5.x's meta-device loader + # (_move_missing_keys_from_meta_to_device) requires -> AttributeError on load. + # Provide a no-tie class-level default; models whose tie_weights() runs set + # their own instance attr, which shadows this, so other loads are unaffected. + # Idempotent: only set when absent. Verified to load CaicedoLab/MorphEm on 5.9.0. + if not isinstance(getattr(transformers.PreTrainedModel, "all_tied_weights_keys", None), dict): + transformers.PreTrainedModel.all_tied_weights_keys = {} + + self.model = AutoModel.from_pretrained(model_name, revision=revision, trust_remote_code=True) + self.target_size = (img_size, img_size) + self.projection = projection + # Expose embed dim for foundation-wrapper parity (dynaclr foundation_engine + # may read it pre-forward). Mirror the katamari reference's 3-tier + # `_infer_embed_dim` (embed_dim -> num_features -> patch_embed.proj.out_channels); + # raise loud if none resolve rather than silently defaulting. + # Verified at load: CaicedoLab/MorphEm self-reports embed_dim == num_features == 384. + self.embed_dim = self._infer_embed_dim(self.model) + + self.freeze = freeze + if freeze: + self.model.requires_grad_(False) + self.model.eval() + # Single-channel contract: MorphEm is a 1-channel ViT (CHAMMI feeds one + # channel at a time). Assert at load so a 3-channel patch_embed surfaces + # immediately instead of erroring deep in forward(). + proj = getattr(getattr(self.model, "patch_embed", None), "proj", None) + in_ch = getattr(proj, "in_channels", None) + if in_ch is not None and in_ch != 1: + raise ValueError( + f"MorphEm expected a single-channel patch_embed (in_channels=1), got {in_ch}. " + "The single-channel feed in forward() would error; revisit channel handling." + ) + + @staticmethod + def _infer_embed_dim(model: nn.Module) -> int: + """Resolve the backbone embedding dimension from common ViT attributes.""" + for attr in ("embed_dim", "num_features"): + value = getattr(model, attr, None) + if value is not None: + return int(value) + proj = getattr(getattr(model, "patch_embed", None), "proj", None) + out_channels = getattr(proj, "out_channels", None) + if out_channels is not None: + return int(out_channels) + raise ValueError("Unable to infer embed_dim from the MorphEm backbone.") + + def train(self, mode: bool = True) -> "MorphEmModel": + """Keep the backbone in eval when frozen.""" + super().train(mode) + if self.freeze: + self.model.eval() + return self + + def preprocess_2d(self, x: Tensor) -> Tensor: + """Convert a raw dataloader tensor to MorphEm input. + + Squeezes a singleton Z (middle slice if Z>1), applies per-image + per-channel spatial z-score (zero mean, unit std), THEN resizes to + ``target_size`` — matching the published recipe ordering + ``Compose([PerImageNormalize(), Resize(224)])`` (normalize before + resize; reversing the order shifts the post-interp mean/scale). + + Parameters + ---------- + x : Tensor + ``(B, C, D, H, W)`` or ``(B, C, H, W)``. + + Returns + ------- + Tensor + ``(B, C, target, target)`` float ready for :meth:`forward`. + """ + if x.ndim == 5: + x = x[:, :, 0] if x.shape[2] == 1 else x[:, :, x.shape[2] // 2] + x = x.to(torch.float32) + # PerImageNormalize: per-image per-channel spatial z-score. Uses the + # (x-m)/(std+eps) form matching CellDinoModel.preprocess_2d (the VisCy + # self_normalize convention) — numerically equivalent to the reference + # InstanceNorm2d's (x-m)/sqrt(var+eps) for any non-degenerate crop. + m = x.mean(dim=(-2, -1), keepdim=True) + s = x.std(dim=(-2, -1), unbiased=False, keepdim=True) + x = (x - m) / (s + 1e-7) + # Resize AFTER normalize (published Compose order). antialias=True matches + # the reference v2.Resize(antialias=True); inert on upscale, correct on downscale. + if x.shape[-2:] != self.target_size: + x = F.interpolate(x, size=self.target_size, mode="bilinear", align_corners=False, antialias=True) + return x + + def forward(self, x: Tensor) -> tuple[Tensor, Tensor]: + """Encode a (preprocessed) image batch to a channel-mean CLS embedding. + + Each channel is encoded independently (MorphEm is single-channel), + and the CLS tokens are mean-pooled over channels to a fixed ``(B, D)``. + + Parameters + ---------- + x : Tensor + ``(B, C, H, W)``. + + Returns + ------- + tuple[Tensor, Tensor] + ``(features, projection(features) or features)``, each ``(B, D)``. + """ + b, c = x.shape[0], x.shape[1] + x = x.reshape(b * c, 1, x.shape[-2], x.shape[-1]) + out = self.model.forward_features(x) + cls = out["x_norm_clstoken"] # (B*C, D) + cls = cls.reshape(b, c, -1).mean(dim=1) # (B, D) + if self.projection is not None: + return cls, self.projection(cls) + return cls, cls diff --git a/packages/viscy-models/tests/test_foundation/test_morphem.py b/packages/viscy-models/tests/test_foundation/test_morphem.py new file mode 100644 index 000000000..a403c17ce --- /dev/null +++ b/packages/viscy-models/tests/test_foundation/test_morphem.py @@ -0,0 +1,110 @@ +"""Tests for the MorphEm foundation wrapper. + +``transformers.AutoModel`` is stubbed so the test never touches the network or +the HF cache; it exercises the real :class:`MorphEmModel` preprocessing and +channel-mean forward contract against a fake ViT-S backbone. +""" + +import pytest +import torch + +from viscy_models.foundation import MorphEmModel + +_EMBED_DIM = 384 +_N_PATCHES = 196 # (224 / 16) ** 2 + + +class _StubBackbone(torch.nn.Module): + """Minimal MorphEm stand-in: single-channel patch embed + forward_features.""" + + def __init__(self, embed_dim: int = _EMBED_DIM) -> None: + super().__init__() + self.embed_dim = embed_dim + self.num_features = embed_dim + self.patch_embed = torch.nn.Module() + self.patch_embed.proj = torch.nn.Conv2d(1, embed_dim, kernel_size=16, stride=16) + + def forward_features(self, x: torch.Tensor) -> dict[str, torch.Tensor]: + n = x.shape[0] + # Make the CLS token depend on the input so embeddings are non-constant. + cls = x.flatten(1).mean(dim=1, keepdim=True).expand(n, self.embed_dim).clone() + return { + "x_norm_clstoken": cls, + "x_norm_patchtokens": torch.zeros(n, _N_PATCHES, self.embed_dim), + } + + +@pytest.fixture +def captured_load(monkeypatch): + """Stub ``AutoModel.from_pretrained`` and capture its call args.""" + captured: dict = {} + + def _fake_from_pretrained(name, **kwargs): + captured["name"] = name + captured["kwargs"] = kwargs + return _StubBackbone() + + monkeypatch.setattr("transformers.AutoModel.from_pretrained", _fake_from_pretrained) + return captured + + +def test_load_passes_trust_remote_code(captured_load): + """The wrapper loads via trust_remote_code and infers the embed dim.""" + model = MorphEmModel(model_name="CaicedoLab/MorphEm") + assert captured_load["name"] == "CaicedoLab/MorphEm" + assert captured_load["kwargs"]["trust_remote_code"] is True + assert captured_load["kwargs"]["revision"] is None + assert model.embed_dim == _EMBED_DIM + + +def test_load_forwards_pinned_revision(captured_load): + """A pinned Hub commit reaches ``from_pretrained`` so the remote code is frozen.""" + MorphEmModel(model_name="CaicedoLab/MorphEm", revision="0e8d58787421f83f975634d72420d85c5dfc9c2c") + assert captured_load["kwargs"]["revision"] == "0e8d58787421f83f975634d72420d85c5dfc9c2c" + assert captured_load["kwargs"]["trust_remote_code"] is True + + +def test_preprocess_2d_normalizes_and_resizes(captured_load): + """5-D input is Z-squeezed, per-image z-scored, then resized to 224.""" + model = MorphEmModel(model_name="CaicedoLab/MorphEm") + x = torch.randn(2, 1, 1, 40, 40) + out = model.preprocess_2d(x) + assert out.shape == (2, 1, 224, 224) + # Per-image z-score happens before resize; upscale bilinear keeps mean ~0. + per_image_mean = out.mean(dim=(-2, -1)) + assert torch.all(per_image_mean.abs() < 0.05) + assert torch.all(out.std(dim=(-2, -1)) > 0.1) + + +def test_forward_returns_features_projection_tuple(captured_load): + """Forward on a single-channel batch returns a (features, proj) (B, D) tuple.""" + model = MorphEmModel(model_name="CaicedoLab/MorphEm") + x = torch.randn(2, 1, 224, 224) + features, projection = model(x) + assert features.shape == (2, _EMBED_DIM) + assert projection.shape == (2, _EMBED_DIM) + assert torch.equal(features, projection) # no projection head -> identity + + +def test_forward_channel_mean(captured_load): + """Multi-channel input is encoded per-channel and mean-pooled to (B, D).""" + model = MorphEmModel(model_name="CaicedoLab/MorphEm") + x = torch.randn(2, 3, 224, 224) + features, _ = model(x) + assert features.shape == (2, _EMBED_DIM) + + +def test_single_channel_assert(monkeypatch): + """A 3-channel patch_embed is rejected at load time.""" + + class _ThreeChannel(_StubBackbone): + def __init__(self) -> None: + super().__init__() + self.patch_embed.proj = torch.nn.Conv2d(3, _EMBED_DIM, kernel_size=16, stride=16) + + monkeypatch.setattr( + "transformers.AutoModel.from_pretrained", + lambda name, **kwargs: _ThreeChannel(), + ) + with pytest.raises(ValueError, match="single-channel"): + MorphEmModel(model_name="CaicedoLab/MorphEm") From 1bf182163196223049ac0a442ba67cfeb7c83af8 Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:48:51 -0700 Subject: [PATCH 10/72] feat(viscy-models): let the PatchGAN discriminator preserve the Z axis Port preserve_z from dynacell-models, so the 3D PatchGAN runs on Z=1 inputs for pix2pix2d (default off, unchanged). Source on dynacell-models: c2d04813. Co-Authored-By: Claude Opus 5.5 --- .../src/viscy_models/gan/patchgan3d.py | 29 ++++++- .../tests/test_gan/test_patchgan3d.py | 76 +++++++++++++++++++ 2 files changed, 101 insertions(+), 4 deletions(-) diff --git a/packages/viscy-models/src/viscy_models/gan/patchgan3d.py b/packages/viscy-models/src/viscy_models/gan/patchgan3d.py index de6ff00a1..e53c420d2 100644 --- a/packages/viscy-models/src/viscy_models/gan/patchgan3d.py +++ b/packages/viscy-models/src/viscy_models/gan/patchgan3d.py @@ -45,6 +45,13 @@ class PatchGAN3D(nn.Module): channel. Default is 64. use_spectral_norm : bool, optional If True, apply ``spectral_norm`` to every conv. Default is True. + preserve_z : bool, optional + If True, layers 1-4 take ``kernel_size=(1, 4, 4)``, ``padding=(0, 1, 1)`` + and unit Z stride, so the Z extent passes through untouched. Required + at ``Z=1``: the default cubic ``kernel_size=4`` with ``padding=1`` + gives a padded Z extent of 3 against a size-4 kernel, which raises. + Leave False for 3D, where it is the published topology. Default is + False. Returns ------- @@ -59,6 +66,7 @@ def __init__( in_channels: int = 2, base_channels: int = 64, use_spectral_norm: bool = True, + preserve_z: bool = False, ) -> None: super().__init__() c1 = base_channels @@ -66,9 +74,16 @@ def __init__( c3 = base_channels * 4 c4 = base_channels * 8 + # Z geometry of layers 1-4. The 3D branch reproduces the published + # cubic kernel exactly; the Z-preserving branch collapses the kernel + # and padding on that axis and drops the Z stride of layers 3-4. + kernel = (1, 4, 4) if preserve_z else 4 + padding = (0, 1, 1) if preserve_z else 1 + stride_z = 1 if preserve_z else 2 + self.layer1 = nn.Sequential( _maybe_spectral_norm( - nn.Conv3d(in_channels, c1, kernel_size=4, stride=(1, 2, 2), padding=1), + nn.Conv3d(in_channels, c1, kernel_size=kernel, stride=(1, 2, 2), padding=padding), use_spectral_norm, ), nn.LeakyReLU(0.2, inplace=True), @@ -76,7 +91,7 @@ def __init__( self.layer2 = nn.Sequential( _maybe_spectral_norm( - nn.Conv3d(c1, c2, kernel_size=4, stride=(1, 2, 2), padding=1), + nn.Conv3d(c1, c2, kernel_size=kernel, stride=(1, 2, 2), padding=padding), use_spectral_norm, ), nn.InstanceNorm3d(c2, affine=True), @@ -85,7 +100,7 @@ def __init__( self.layer3 = nn.Sequential( _maybe_spectral_norm( - nn.Conv3d(c2, c3, kernel_size=4, stride=(2, 2, 2), padding=1), + nn.Conv3d(c2, c3, kernel_size=kernel, stride=(stride_z, 2, 2), padding=padding), use_spectral_norm, ), nn.InstanceNorm3d(c3, affine=True), @@ -94,7 +109,7 @@ def __init__( self.layer4 = nn.Sequential( _maybe_spectral_norm( - nn.Conv3d(c3, c4, kernel_size=4, stride=(2, 2, 2), padding=1), + nn.Conv3d(c3, c4, kernel_size=kernel, stride=(stride_z, 2, 2), padding=padding), use_spectral_norm, ), nn.InstanceNorm3d(c4, affine=True), @@ -153,6 +168,10 @@ class MultiScalePatchGAN3D(nn.Module): use_spectral_norm : bool, optional If True, apply spectral normalization to every conv in each scale. Default is True. + preserve_z : bool, optional + Forwarded to every :class:`PatchGAN3D`. Set True for a Z-preserving + (``Z=1``) discriminator. The inter-scale pooling is already + YX-only, so no other change is needed. Default is False. Returns ------- @@ -166,6 +185,7 @@ def __init__( base_channels: int = 64, num_scales: int = 2, use_spectral_norm: bool = True, + preserve_z: bool = False, ) -> None: super().__init__() if num_scales < 1: @@ -177,6 +197,7 @@ def __init__( in_channels=in_channels, base_channels=base_channels, use_spectral_norm=use_spectral_norm, + preserve_z=preserve_z, ) for _ in range(num_scales) ] diff --git a/packages/viscy-models/tests/test_gan/test_patchgan3d.py b/packages/viscy-models/tests/test_gan/test_patchgan3d.py index b2bc8af9d..d7bf48915 100644 --- a/packages/viscy-models/tests/test_gan/test_patchgan3d.py +++ b/packages/viscy-models/tests/test_gan/test_patchgan3d.py @@ -1,5 +1,6 @@ """Tests for 3D PatchGAN discriminators.""" +import pytest import torch from viscy_models.gan import MultiScalePatchGAN3D, PatchGAN3D @@ -63,3 +64,78 @@ def test_multi_scale_patchgan3d_single_scale_ablation(): out = model(x) assert isinstance(out, list) assert len(out) == 1 + + +def test_patchgan3d_default_raises_at_unit_depth(): + """The cubic default cannot run at Z=1 — this is what preserve_z exists for.""" + model = PatchGAN3D(in_channels=2) + with pytest.raises(RuntimeError, match="Kernel size can't be greater than actual input size"): + model(torch.randn(1, 2, 1, 64, 64)) + + +def test_patchgan3d_preserve_z_runs_at_unit_depth(): + """preserve_z=True accepts Z=1 and keeps the Z extent at 1.""" + model = PatchGAN3D(in_channels=2, preserve_z=True) + y = model(torch.randn(2, 2, 1, 64, 64)) + assert y.ndim == 5 + assert y.shape[:2] == (2, 1) + assert y.shape[2] == 1, f"Z must pass through, got {y.shape}" + assert y.shape[-1] == y.shape[-2], f"Expected square YX, got {y.shape}" + + +def test_patchgan3d_preserve_z_keeps_depth_for_a_slab() -> None: + """Z is preserved, not merely tolerated: a 5-plane slab stays 5 planes. + + Layers 3-4 stride Z by 2 in the 3D topology, which would halve a slab + twice. ``preserve_z`` drops that stride, so the discriminator never mixes + planes the Z-preserving generator kept separate. + """ + model = PatchGAN3D(in_channels=2, preserve_z=True) + y = model(torch.randn(1, 2, 5, 64, 64)) + assert y.shape[2] == 5, f"expected Z=5 through the discriminator, got {y.shape}" + + +def test_patchgan3d_preserve_z_leaves_the_3d_topology_untouched() -> None: + """preserve_z=False must reproduce the published 3D discriminator exactly. + + Guards the shared code path: the 2D arm was added by parameterizing the + same convs the 14 pix2pix3d leaves train, so an accidental change to the + default would silently alter every published GAN number. + """ + torch.manual_seed(0) + default = PatchGAN3D(in_channels=2) + torch.manual_seed(0) + explicit = PatchGAN3D(in_channels=2, preserve_z=False) + for (name, a), (_, b) in zip(default.named_parameters(), explicit.named_parameters(), strict=True): + assert torch.equal(a, b), f"{name} differs" + for layer in (default.layer1, default.layer2): + assert layer[0].kernel_size == (4, 4, 4) + assert layer[0].padding == (1, 1, 1) + assert layer[0].stride == (1, 2, 2) + for layer in (default.layer3, default.layer4): + assert layer[0].kernel_size == (4, 4, 4) + assert layer[0].stride == (2, 2, 2) + x = torch.randn(1, 2, 8, 64, 64) + with torch.no_grad(): + assert torch.equal(default(x), explicit(x)) + + +def test_multi_scale_patchgan3d_preserve_z_at_unit_depth() -> None: + """The multi-scale wrapper forwards preserve_z and pools YX only.""" + model = MultiScalePatchGAN3D(in_channels=2, num_scales=2, preserve_z=True) + out = model(torch.randn(1, 2, 1, 128, 128)) + assert len(out) == 2 + assert all(o.shape[2] == 1 for o in out), [tuple(o.shape) for o in out] + assert out[1].shape[-1] < out[0].shape[-1] + + +def test_patchgan3d_preserve_z_gradient_flow() -> None: + """Every conv weight receives a gradient at Z=1.""" + model = PatchGAN3D(in_channels=2, preserve_z=True) + model(torch.randn(2, 2, 1, 64, 64)).sum().backward() + missing = [ + name + for name, param in model.named_parameters() + if "weight" in name and (param.grad is None or param.grad.abs().sum().item() == 0.0) + ] + assert not missing, f"no gradient reached {missing}" From f5541f509490c1398b340db67f9867adfe1c356b Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:48:52 -0700 Subject: [PATCH 11/72] feat(viscy-models): UNet3D downsample_z for FNet-2D; reject non-5D input Port from dynacell-models: - UNet3D(downsample_z=True): False keeps Z through the encoder, which is how FNet2D runs on single planes (default unchanged); - UNet3DBase.forward raises on non-5D input, and a comment flags the ConvTranspose checkerboard artifact. Source on dynacell-models: a556bc9d (#484), 83a1d69c, 16b1d315. Co-Authored-By: Claude Opus 5.5 --- .../src/viscy_models/unet/unet3d.py | 18 ++++++++---- .../src/viscy_models/unet/unet3d_base.py | 29 +++++++++++++++++++ .../tests/test_unet/test_unet3d.py | 27 +++++++++++++++++ .../tests/test_unet/test_unet3d_base.py | 7 +++++ 4 files changed, 76 insertions(+), 5 deletions(-) diff --git a/packages/viscy-models/src/viscy_models/unet/unet3d.py b/packages/viscy-models/src/viscy_models/unet/unet3d.py index ed32e1396..a190afbb1 100644 --- a/packages/viscy-models/src/viscy_models/unet/unet3d.py +++ b/packages/viscy-models/src/viscy_models/unet/unet3d.py @@ -39,9 +39,10 @@ class Unet3d(UNet3DBase): FNet-configured preset of the unified 3D U-Net base with BatchNorm, ReLU activations, non-residual double-conv blocks, and a convolutional - bottleneck. Downsamples all three spatial dimensions. + bottleneck. Downsamples Y and X, and (when ``downsample_z=True``) Z. - All spatial dimensions (Z, Y, X) must be divisible by ``2**depth``. + Each downsampled spatial dimension must be divisible by ``2**depth``: Y and + X always, and Z only when ``downsample_z=True``. Parameters ---------- @@ -56,8 +57,14 @@ class Unet3d(UNet3DBase): in_stack_depth : int or None Z-window size. Stored for engine compatibility (``example_input_array``, ``DivisiblePad``, sliding window prediction). - The model itself handles arbitrary Z as long as it is divisible - by ``2**depth``. + The model itself handles arbitrary Z; when ``downsample_z=True`` the Z + size must be divisible by ``2**depth`` (no constraint when ``False``). + downsample_z : bool + Whether to downsample the Z axis in the encoder (``True`` preserves the + FNet3D behavior). Set ``False`` for a Z-preserving 2D-style network + (stride ``(1, 2, 2)``, ``ConvTranspose3d`` kernel ``(1, 3, 3)``), which + is required to run at ``Z=1`` without tripping the base + ``D % 2**depth`` divisibility check. """ def __init__( @@ -67,6 +74,7 @@ def __init__( depth: int = 4, mult_chan: int = 32, in_stack_depth: int | None = None, + downsample_z: bool = True, ) -> None: dims = [mult_chan * (2**i) for i in range(depth + 1)] bottleneck = ConvBottleneck3D(dims[-1], residual=False, norm="batch", activation="relu") @@ -76,7 +84,7 @@ def __init__( dims=dims, num_res_block=[1] * depth, bottleneck=bottleneck, - downsample_z=True, + downsample_z=downsample_z, residual=False, norm="batch", activation="relu", diff --git a/packages/viscy-models/src/viscy_models/unet/unet3d_base.py b/packages/viscy-models/src/viscy_models/unet/unet3d_base.py index d5aae7ef5..2be04af97 100644 --- a/packages/viscy-models/src/viscy_models/unet/unet3d_base.py +++ b/packages/viscy-models/src/viscy_models/unet/unet3d_base.py @@ -93,6 +93,27 @@ def __init__( self._cond_inconv = nn.Conv3d(cond_channels, dims[0], kernel_size=3, stride=1, padding=1) # ── Stride configuration ──────────────────────────────────────── + # KNOWN ARTIFACT: kernel 3 with stride 2 is the checkerboard condition + # (Odena et al., "Deconvolution and Checkerboard Artifacts", 2016). + # 3 is not divisible by 2, so kernel placements overlap unevenly and + # each ConvTranspose imprints a 2-periodic modulation; three stacked + # upsamples put energy at 2, 4 and 8 px. It is present IN distribution, + # not only out of it: on an iPSC-trained membrane prediction of an iPSC + # FOV the period-2 component measured 216x its ground-truth amplitude + # and period-4 67x. Out of distribution it grows further -- on an + # A549-trained ER prediction of an iPSC FOV the 4 px peak reached 16x + # its spectral background. It is visible in every + # model built on this base (UNetViT3D and FNet3D alike), which is how + # it was traced here -- a shared artifact across two otherwise + # unrelated architectures. + # + # The clean fix is kernel_size 4 with output_padding 0 (kernel + # divisible by stride -> uniform overlap), or nearest-neighbour + # Upsample + Conv3d. Both change weight shapes and so invalidate every + # existing checkpoint, which is why this is documented rather than + # changed: the published benchmark numbers are tied to these weights. + # For inference-time suppression on existing checkpoints see + # ``dynacell.engine._phase_shift_average``. if downsample_z: down_stride = (2, 2, 2) up_kwargs = dict(kernel_size=3, stride=(2, 2, 2), padding=1, output_padding=1) @@ -158,7 +179,15 @@ def forward(self, x: Tensor, cond: Tensor | None = None, t: Tensor | None = None ------- Tensor Output tensor of shape ``(B, out_channels, D, H, W)``. + + Raises + ------ + ValueError + If ``x`` is not a 5D tensor, or a downsampled spatial dimension is + not divisible by ``2**num_blocks``. """ + if x.ndim != 5: + raise ValueError(f"Expected 5D input (B, C, D, H, W), got {x.ndim}D.") for dim_name, size in zip(("D", "H", "W"), x.shape[2:]): if self.downsamples_z or dim_name != "D": if size % self._divisor != 0: diff --git a/packages/viscy-models/tests/test_unet/test_unet3d.py b/packages/viscy-models/tests/test_unet/test_unet3d.py index 1e1ed76e5..58bf4e50c 100644 --- a/packages/viscy-models/tests/test_unet/test_unet3d.py +++ b/packages/viscy-models/tests/test_unet/test_unet3d.py @@ -67,6 +67,33 @@ def test_engine_attributes(): assert model.downsamples_z is True +def test_downsample_z_default_preserves_fnet3d(): + """Default downsample_z keeps the FNet3D Z-downsampling behavior.""" + model = Unet3d(depth=4, mult_chan=32, in_stack_depth=32) + assert model.downsamples_z is True + + +def test_downsample_z_false_z1_forward(): + """downsample_z=False enables the FNet2D use case: a Z=1 forward runs and preserves Z. + + With downsample_z=True (the FNet3D default) a Z=1 input trips the base + ``D % 2**depth`` divisor check; the Z-preserving path must skip that check. + """ + model = Unet3d(in_channels=1, out_channels=1, depth=4, mult_chan=32, downsample_z=False) + assert model.downsamples_z is False + x = torch.randn(2, 1, 1, 64, 64) # Y,X divisible by 2**4=16; Z=1 + y = model(x) + assert y.shape == (2, 1, 1, 64, 64) + + +def test_downsample_z_false_skips_z_divisor_check(): + """With downsample_z=False, Z need not be divisible by 2**depth (only Y/X are checked).""" + model = Unet3d(in_channels=1, out_channels=1, depth=2, mult_chan=16, downsample_z=False) + x = torch.randn(1, 1, 3, 16, 16) # Z=3 not divisible by 2^2=4, but Z is not downsampled + y = model(x) + assert y.shape == (1, 1, 3, 16, 16) + + def test_state_dict_keys(): """State dict uses iterative encoder-decoder key structure.""" model = Unet3d(in_channels=1, out_channels=1, depth=2, mult_chan=16) diff --git a/packages/viscy-models/tests/test_unet/test_unet3d_base.py b/packages/viscy-models/tests/test_unet/test_unet3d_base.py index cd54eb260..aa6c59dd2 100644 --- a/packages/viscy-models/tests/test_unet/test_unet3d_base.py +++ b/packages/viscy-models/tests/test_unet/test_unet3d_base.py @@ -173,3 +173,10 @@ def test_dims_mismatch_raises(): """len(dims) != len(num_res_block) + 1 raises ValueError.""" with pytest.raises(ValueError, match="len\\(dims\\)"): _make_base(dims=(16, 32, 64), num_res_block=(1,)) + + +def test_forward_non_5d_input_raises(): + """A non-5D input raises a clear ValueError, not a confusing Conv3d channel error.""" + model = _make_base() + with pytest.raises(ValueError, match="Expected 5D input"): + model(torch.randn(2, 1, 16, 16)) # 4D: a squeezed Z dim From dc891f5412bccb02b3df179333332f8dc8634155 Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:49:02 -0700 Subject: [PATCH 12/72] fix(viscy-transforms): stop BatchedRandAffined blanking singleton axes Port 9640537d from dynacell-models: a size-1 spatial axis (Z=1 for 2D models) gets an identity row in the affine, instead of being resampled off the volume and zeroed. Co-Authored-By: Claude Opus 5.5 --- .../src/viscy_transforms/_affine.py | 39 +++++- .../viscy-transforms/tests/test_affine.py | 121 ++++++++++++++++++ 2 files changed, 157 insertions(+), 3 deletions(-) diff --git a/packages/viscy-transforms/src/viscy_transforms/_affine.py b/packages/viscy-transforms/src/viscy_transforms/_affine.py index 34f51100d..8c97524d2 100644 --- a/packages/viscy-transforms/src/viscy_transforms/_affine.py +++ b/packages/viscy-transforms/src/viscy_transforms/_affine.py @@ -20,10 +20,17 @@ class _PaddedRandomAffine3D(RandomAffine3D): - """RandomAffine3D with configurable padding_mode. + """RandomAffine3D with configurable padding_mode and depth-1 safety. Kornia 0.8.x hard-codes ``padding_mode='zeros'`` in apply_transform. - This subclass overrides that call to forward the user-specified mode. + This subclass overrides that call to forward the user-specified mode, + and forces the matrix row of any singleton spatial axis to identity. + + Note the neutralized row is applied to a copy, so + ``self._transform_matrix`` (and therefore + :meth:`RandomAffine3D.inverse`) still records the un-neutralized matrix + on a singleton axis. Nothing in VisCy reads those, but do not rely on + them for such inputs without re-applying the same neutralization. """ def __init__(self, *args: object, padding_mode: str = "zeros", **kwargs: object) -> None: @@ -37,9 +44,29 @@ def apply_transform( flags: dict, transform: Tensor | None = None, ) -> Tensor: + # clone() is load-bearing: transform[:, :3] is a VIEW into the same + # tensor kornia stores as self._transform_matrix right after this + # returns, so mutating it in place would corrupt the recorded + # transform (and hence RandomAffine3D.inverse()). It is not about + # contiguity -- warp_affine3d accepts the non-contiguous view -- and + # not about the source/target pairing, which kornia rebuilds per key. + matrix = transform[:, :3].clone() + # Kornia normalizes pixel coordinates with a 2 / (size - 1) scale and + # guards a singleton axis by dividing by eps=1e-14 instead, so that + # axis' scale blows up to ~2e14. Any non-identity entry in the + # corresponding matrix row then pushes every sampled coordinate out of + # bounds and padding_mode="zeros" blanks the volume. A singleton axis + # has no extent to rotate, shear, scale or translate along, so identity + # is the correct row. Other rows are left alone and still warp + # normally; their terms for this axis are divided by the same 2e14 and + # vanish. Rows are ordered (x, y, z), i.e. (W, H, D). + for row, size in enumerate((input.shape[-1], input.shape[-2], input.shape[-3])): + if size == 1: + matrix[:, row] = 0.0 + matrix[:, row, row] = 1.0 return warp_affine3d( input, - transform[:, :3, :], + matrix, (input.shape[-3], input.shape[-2], input.shape[-1]), flags["resample"].name.lower(), padding_mode=self._padding_mode, @@ -289,6 +316,12 @@ def _scale_z_shear_facets(params: dict[str, Tensor], shape: torch.Size) -> dict[ produces ~64x more displacement than the same angle across Z=8. This method reduces Z-related facets so the pixel displacement in Z is proportional to the Z depth. + + This is augmentation *policy* and is opt-out via ``scale_z_shear``. + Depth-1 safety is a correctness invariant handled separately, in + ``_PaddedRandomAffine3D.apply_transform`` — do not add depth-1 + handling here, where it would cover shear only and could be + switched off. """ z_depth = shape[2] yx_size = max(shape[3], shape[4]) diff --git a/packages/viscy-transforms/tests/test_affine.py b/packages/viscy-transforms/tests/test_affine.py index c9852ca3f..08a5195f4 100644 --- a/packages/viscy-transforms/tests/test_affine.py +++ b/packages/viscy-transforms/tests/test_affine.py @@ -1,5 +1,6 @@ import math +import pytest import torch from viscy_transforms import BatchedRandAffined @@ -302,3 +303,123 @@ def test_safe_crop_size_preserves_key_consistency(): torch.manual_seed(42) out = t(sample) assert torch.equal(out["source"], out["target"]) + + +def test_affine_depth_one_preserves_data(): + """A depth-1 volume must not be blanked by the affine. + + Kornia normalizes pixel coordinates with a ``2 / (D - 1)`` scale, which + at ``D == 1`` becomes ~2e14. Any non-identity entry in the transform's Z + row is then multiplied by that factor, pushing every sampled coordinate + out of bounds so ``padding_mode="zeros"`` returns an all-zero tensor. + + The 2D training overlays (``z_window_size: 1``) use exactly this shear + configuration, so a regression here silently blanks training data. + """ + t = BatchedRandAffined( + keys=["source", "target"], + prob=1.0, + rotate_range=[0, 0, 0], + shear_range=[0.0, 0.05, 0.05], + scale_range=[[1, 1], [0.5, 1.5], [0.5, 1.5]], + ) + base = torch.ones(4, 1, 1, 64, 64) + sample = {"source": base.clone(), "target": base.clone()} + + torch.manual_seed(0) + out = t(sample) + + # The regression signature is exactly 0.0. A fractional threshold would be + # seed-fragile: scale_range lets YX shrink to 0.5, legitimately taking a + # sample to ~0.30 nonzero on some seeds. + nonzero = (out["source"] != 0).float().mean(dim=(1, 2, 3, 4)) + assert (nonzero > 0).all(), f"depth-1 volume was blanked: per-sample nonzero {nonzero.tolist()}" + assert torch.equal(out["source"], out["target"]) + + +def test_affine_depth_one_still_transforms_in_plane(): + """Neutralizing the Z row must not disable the YX transform at D=1.""" + t = BatchedRandAffined( + keys=["source"], + prob=1.0, + rotate_range=[3.14, 0, 0], + scale_range=[[1, 1], [0.5, 1.5], [0.5, 1.5]], + ) + base = torch.zeros(2, 1, 1, 64, 64) + base[:, :, :, 16:48, 16:48] = 1.0 + + torch.manual_seed(0) + out = t({"source": base.clone()})["source"] + + assert (out != 0).any(), "depth-1 volume was blanked" + assert not torch.equal(out, base), "YX transform was not applied at D=1" + + +@pytest.mark.parametrize( + "index,name", + list(enumerate(["sxy", "sxz", "syx", "syz", "szx", "szy"])), +) +def test_affine_depth_one_all_shear_facets(index: int, name: str): + """Every individual shear facet is safe at depth 1.""" + shear = [(0.0, 0.0)] * 6 + shear[index] = (-0.05, 0.05) + t = BatchedRandAffined(keys=["source"], prob=1.0, shear_range=shear) + + torch.manual_seed(0) + out = t({"source": torch.ones(2, 1, 1, 64, 64)})["source"] + + assert float(out.mean()) > 0.5, f"facet {name} blanked the depth-1 volume" + + +@pytest.mark.parametrize( + "shape,label", + [ + ((2, 1, 1, 64, 64), "depth"), + ((2, 1, 8, 1, 64), "height"), + ((2, 1, 8, 64, 1), "width"), + ], +) +def test_affine_singleton_axis_preserves_data(shape: tuple[int, ...], label: str): + """Any singleton spatial axis is safe, not just depth. + + Kornia's ``2 / (size - 1)`` normalization degenerates identically for a + singleton W or H, so the guard covers every spatial axis. + """ + t = BatchedRandAffined(keys=["source"], prob=1.0, shear_range=[0.0, 0.05, 0.05]) + + torch.manual_seed(0) + out = t({"source": torch.ones(*shape)})["source"] + + assert (out != 0).any(), f"singleton {label} axis blanked the volume" + + +def test_affine_depth_one_partial_batch(): + """prob < 1 at depth 1 -- the only configuration production runs. + + The 2D overlays all use ``prob: 0.8``, which takes Kornia's mixed + ``to_apply`` branch: ``apply_transform`` is called with a *sliced* batch + and the result is merged back. The ``prob=1.0`` tests take a different + branch and would not catch a guard that read a batch-level shape. + """ + t = BatchedRandAffined( + keys=["source", "target"], + prob=0.5, + rotate_range=[0, 0, 0], + shear_range=[0.0, 0.05, 0.05], + scale_range=[[1, 1], [0.5, 1.5], [0.5, 1.5]], + ) + base = torch.ones(8, 1, 1, 64, 64) + + torch.manual_seed(0) + out = t({"source": base.clone(), "target": base.clone()}) + + # Pin that the batch really was partial, or this silently degrades into + # another prob=1 (or prob=0) test and stops covering the sliced branch. + transformed = [not torch.equal(out["source"][i], base[i]) for i in range(base.shape[0])] + assert 0 < sum(transformed) < base.shape[0], ( + f"batch was not partial: {sum(transformed)}/{base.shape[0]} transformed" + ) + + nonzero = (out["source"] != 0).float().mean(dim=(1, 2, 3, 4)) + assert (nonzero > 0).all(), f"partial batch had blanked samples: {nonzero.tolist()}" + assert torch.equal(out["source"], out["target"]) From b7011c087184cdee3b14e9b60fd36adc82d8038d Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:49:03 -0700 Subject: [PATCH 13/72] perf(viscy-transforms): mark the sampled normalizers pointwise NormalizeSampled and MinMaxSampled set pointwise = True, which lets the read-once predict path in viscy-data normalize a whole volume once instead of once per window. Source on dynacell-models: 8e74a7eb (#532). Co-Authored-By: Claude Opus 5.5 --- packages/viscy-transforms/src/viscy_transforms/_normalize.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/packages/viscy-transforms/src/viscy_transforms/_normalize.py b/packages/viscy-transforms/src/viscy_transforms/_normalize.py index 50457dd66..1de096fa0 100644 --- a/packages/viscy-transforms/src/viscy_transforms/_normalize.py +++ b/packages/viscy-transforms/src/viscy_transforms/_normalize.py @@ -26,6 +26,9 @@ def _match_image(tensor: Tensor, target: Tensor) -> Tensor: class NormalizeSampled(MapTransform): is_spatial = False + # Each voxel maps through precomputed statistics alone, so a whole volume normalized + # once equals each window normalized on its own (``SlidingWindowDataset.cache_volume``). + pointwise = True """Normalize using precomputed statistics stored in ``sample["norm_meta"]``. @@ -82,6 +85,8 @@ def __call__(self, sample: Sample) -> Sample: class MinMaxSampled(MapTransform): is_spatial = False + # See NormalizeSampled.pointwise. + pointwise = True """Normalize to [-1, 1] by clipping then rescaling with precomputed range statistics. From 860d0f8a789bd76e173b73213071b908eefd2619 Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:49:04 -0700 Subject: [PATCH 14/72] test(viscy-transforms): make the Gaussian-noise statistics test deterministic Port 3409560f (#513) from dynacell-models. Co-Authored-By: Claude Opus 5.5 --- packages/viscy-transforms/tests/test_noise.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/packages/viscy-transforms/tests/test_noise.py b/packages/viscy-transforms/tests/test_noise.py index 64c2f1940..0a480d510 100644 --- a/packages/viscy-transforms/tests/test_noise.py +++ b/packages/viscy-transforms/tests/test_noise.py @@ -1,3 +1,5 @@ +import math + import pytest import torch from monai.transforms import Compose @@ -34,11 +36,14 @@ def test_batched_gaussian_noise(device, ndim, prob, compose): @pytest.mark.parametrize("std", [2.0, 4.0]) @pytest.mark.parametrize("sample_std", [True, False]) def test_batched_gaussian_noise_statistics(mean, std, sample_std): + torch.manual_seed(0) img = torch.zeros(64, 8, 8, 8, 8) transform = BatchedRandGaussianNoise(prob=1.0, mean=mean, std=std, sample_std=sample_std) result = transform(img) assert (result.mean() - mean).abs() < 0.5 - expected_std = std / 2.0 if sample_std else std + # sample_std draws each sample's std from U(0, std); the pooled std is then + # sqrt(E[s^2]) = std / sqrt(3), not the mean draw std / 2. + expected_std = std / math.sqrt(3) if sample_std else std assert (result.std() - expected_std).abs() < 0.6 From c239394ba111df5dffb2e4841d81dd912988938b Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:49:48 -0700 Subject: [PATCH 15/72] build: parallel test runs with pytest-xdist Port dfcf9a53 (#512) from dynacell-models: pytest-xdist joins the test group, and a root conftest.py pins OMP/MKL/OpenBLAS to one thread under each xdist worker. Without the pin every worker's torch sizes its pool to all cores, which made `-n 11` 10x slower than it should be and timed out subprocess tests. CLAUDE.md documents the usage. Co-Authored-By: Claude Opus 5.5 --- CLAUDE.md | 2 ++ conftest.py | 14 ++++++++++++++ pyproject.toml | 2 +- 3 files changed, 17 insertions(+), 1 deletion(-) create mode 100644 conftest.py diff --git a/CLAUDE.md b/CLAUDE.md index 6801f8eba..d83a7e6f4 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -117,6 +117,8 @@ uv run pytest packages/viscy-models/ # single package (models) Prefer `{file}_test.py` in the same directory as `{file}.py`, unless there are import issues, in which case use `tests/`. +Run the suite in parallel with `pytest -n ` (pytest-xdist, in the `test` group). The root `conftest.py` pins each worker to one OpenMP/BLAS thread. Without that pin, torch in every worker grabs every core and the parallel run is 10x slower than it should be. `-n auto` counts the cores the shell may use, so inside a 1-CPU `srun` step it runs a single worker; give the step more CPUs (`srun --overlap -c N`) first. + --- ## Project Conventions diff --git a/conftest.py b/conftest.py new file mode 100644 index 000000000..c8b776b03 --- /dev/null +++ b/conftest.py @@ -0,0 +1,14 @@ +"""Repo-wide pytest setup, loaded before every package's own conftest.""" + +import os + +# Under pytest-xdist every worker is a separate process, and torch/OpenMP size +# their thread pools to all visible cores by default, so `-n N` runs ~N x cores +# threads. On 11 cores that made the suite 10x slower (1242 s vs 117 s) and +# timed out subprocess tests. xdist sets PYTEST_XDIST_WORKER before this module +# is imported, which is before any test module imports torch. Assigned, not +# setdefault: an inherited limit (a job script exporting OMP_NUM_THREADS=16) +# would otherwise oversubscribe the cores the same way. +if "PYTEST_XDIST_WORKER" in os.environ: + for var in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"): + os.environ[var] = "1" diff --git a/pyproject.toml b/pyproject.toml index efde37d5a..bff73e881 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -32,7 +32,7 @@ urls.Repository = "https://github.com/mehta-lab/VisCy" [dependency-groups] dev = [ { include-group = "jupyter" }, { include-group = "test" } ] -test = [ "pytest>=9.0.2", "pytest-cov>=7" ] +test = [ "pytest>=9.0.2", "pytest-cov>=7", "pytest-xdist>=3.8" ] jupyter = [ "ipykernel>=7.1", "jupyterlab>=4.5.3" ] doc = [ "mike @ git+https://github.com/squidfunk/mike.git", From 451fea64ac8bb8a7f7bee316541db5271c6b3462 Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:49:49 -0700 Subject: [PATCH 16/72] test: register pytest markers at the root and make them strict Port the marker half of c50300f5 (#489) from dynacell-models. strict_markers = true turns an unregistered marker into a collection error, so a typo'd marker can no longer silently decorate nothing. hpc_integration moves from the cytoland and dynaclr conftests to the root: an addinivalue_line registration only holds when that conftest is in the invocation's ancestry. dynaclr drops its own testpaths so the root ini applies. requires_data is registered too: main's applications/dynacell/tools/generate_grouped_eval_configs_test.py uses it, and strict markers would otherwise drop that module at collection. (dynacell-models no longer uses the marker; the dynacell PR that follows removes the registration with it.) Co-Authored-By: Claude Opus 5.5 --- applications/cytoland/tests/conftest.py | 5 ----- applications/dynaclr/pyproject.toml | 3 --- applications/dynaclr/tests/conftest.py | 1 - pyproject.toml | 18 +++++++++++++++++- 4 files changed, 17 insertions(+), 10 deletions(-) diff --git a/applications/cytoland/tests/conftest.py b/applications/cytoland/tests/conftest.py index 36530291d..28f6ae67b 100644 --- a/applications/cytoland/tests/conftest.py +++ b/applications/cytoland/tests/conftest.py @@ -54,11 +54,6 @@ ) -def pytest_configure(config): - """Register custom markers.""" - config.addinivalue_line("markers", "hpc_integration: requires HPC paths and GPU") - - @pytest.fixture def checkpoint_path(): """Return path to vscyto3d checkpoint.""" diff --git a/applications/dynaclr/pyproject.toml b/applications/dynaclr/pyproject.toml index 4cce8f180..76ed2e3f7 100644 --- a/applications/dynaclr/pyproject.toml +++ b/applications/dynaclr/pyproject.toml @@ -96,9 +96,6 @@ source = "uv-dynamic-versioning" [tool.hatch.build.targets.wheel] packages = [ "src/dynaclr" ] -[tool.pytest.ini_options] -testpaths = [ "tests" ] - [tool.uv-dynamic-versioning] vcs = "git" style = "pep440" diff --git a/applications/dynaclr/tests/conftest.py b/applications/dynaclr/tests/conftest.py index 855efe84f..f4d9fae0c 100644 --- a/applications/dynaclr/tests/conftest.py +++ b/applications/dynaclr/tests/conftest.py @@ -336,7 +336,6 @@ def pytest_configure(config): # ArrowStringArray index. Remove when anndata fixes zarr 3 support. # See: https://github.com/scverse/anndata/issues/1510 pd.options.future.infer_string = False - config.addinivalue_line("markers", "hpc_integration: requires HPC paths and GPU") def pytest_collection_modifyitems(config, items): diff --git a/pyproject.toml b/pyproject.toml index bff73e881..134d60ef5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -101,8 +101,24 @@ minversion = "9.0" testpaths = [ "packages/*/tests", "applications/*/tests" ] addopts = [ "-ra", "-q", "--import-mode=importlib", "-m", "not slow" ] pythonpath = [ "applications/dynacell/tools" ] +# Set as an ini option, NOT as --strict-markers in addopts. pytest >= 9 backs the +# flag with this ini option and only honours the flag from the command line — in +# addopts it parses (config.option.strict_markers reads True) but never enforces, +# so an unregistered marker still merely warns. Verified on pytest 9.0.3. +strict_markers = true markers = [ - "slow: marks tests requiring GPU/HPC resources (deselect with -m 'not slow')", + # strict_markers above turns an unregistered marker into a collection error. + # Without it a typo'd or invented marker silently decorates nothing, so the + # test it was meant to gate runs anyway (and asserts on whatever the shared + # HPC tree happens to hold). + # + # Register every marker HERE, not via addinivalue_line in an application + # conftest: that only registers when the conftest is in the invocation's + # ancestry, so a marked test outside that app collects fine from the repo root + # and errors when run as a single file. + "slow: marks tests requiring GPU/HPC resources or live HPC data (deselect with -m 'not slow')", + "hpc_integration: requires HPC data paths and a CUDA GPU", + "requires_data: reads the live dynacell training tree on disk (deselect with -m 'not requires_data')", ] [tool.uv-dynamic-versioning] From cd3ed0fbacce407ebf059cd16b06049f1e257c17 Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:49:51 -0700 Subject: [PATCH 17/72] build: put the dynacell hf_demo on the pytest pythonpath Port the root half of 7b7cb431 (#523) from dynacell-models so the HF demo's tests import its app module. The directory already exists on main. Co-Authored-By: Claude Opus 5.5 --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 134d60ef5..4d6138e55 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -100,7 +100,7 @@ lint.pydocstyle.convention = "numpy" minversion = "9.0" testpaths = [ "packages/*/tests", "applications/*/tests" ] addopts = [ "-ra", "-q", "--import-mode=importlib", "-m", "not slow" ] -pythonpath = [ "applications/dynacell/tools" ] +pythonpath = [ "applications/dynacell/tools", "applications/dynacell/examples/hf_demo" ] # Set as an ini option, NOT as --strict-markers in addopts. pytest >= 9 backs the # flag with this ini option and only honours the flag from the command line — in # addopts it parses (config.option.strict_markers reads True) but never enforces, From ce2a03cf93c8cc487fad52f7de83d593b36cc4e9 Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:50:06 -0700 Subject: [PATCH 18/72] test(dynaclr): join annotations on the full fov_name Port d1ea492f from dynacell-models. The orchestrated linear-classifier fixture joined on the first fov_name component, which failed 7 tests on main once pytest collects dynaclr's colocated *_test.py. Co-Authored-By: Claude Opus 5.5 --- .../evaluation/linear_classifiers/orchestrated_test.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/applications/dynaclr/src/dynaclr/evaluation/linear_classifiers/orchestrated_test.py b/applications/dynaclr/src/dynaclr/evaluation/linear_classifiers/orchestrated_test.py index a28db7569..fc90cadf4 100644 --- a/applications/dynaclr/src/dynaclr/evaluation/linear_classifiers/orchestrated_test.py +++ b/applications/dynaclr/src/dynaclr/evaluation/linear_classifiers/orchestrated_test.py @@ -76,12 +76,12 @@ def _make_annotations( ) -> Path: """Create a synthetic annotation CSV with infection_state and organelle_state labels. - fov_name is stored as the first path component only (e.g. "A/1/FOV0" → "A"), - matching what load_annotation_anndata extracts from obs via .str.split("/").str[0]. + fov_name is stored in full (e.g. "A/1/FOV0"), matching the join key + load_annotation_anndata actually builds: it normalizes both sides with + .str.strip("/") and joins on the whole path, never a split component. """ labels = ["uninfected" if i % 3 != 0 else "infected" for i in range(len(fov_names))] - # Extract first path component to match the join key in load_annotation_anndata - fov_first = [str(f).split("/")[0] for f in fov_names] + fov_first = [str(f) for f in fov_names] data: dict = { "fov_name": fov_first, "t": ts, From 6cfde6868e5331e09bb0e8dc008f2898fb32b7e3 Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:50:13 -0700 Subject: [PATCH 19/72] docs(cytoland): correct the Spotlight recipe comments Port the cytoland recipe comment fixes from 40de7939 (#498): the preprocess flags take explicit values (`--compute_otsu true --compute_fg_masks true`), fg_threshold and nonzero_threshold are inert while fg_mask_key is set, and the Otsu-centred target is what makes 0 the FG/BG boundary. Comments only. Co-Authored-By: Claude Opus 5.5 --- .../examples/configs/recipes/modes/spotlight.yml | 11 ++++++++--- .../examples/configs/vscyto3d/train_spotlight.yml | 2 +- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/applications/cytoland/examples/configs/recipes/modes/spotlight.yml b/applications/cytoland/examples/configs/recipes/modes/spotlight.yml index be9b5d295..cbe4e51d0 100644 --- a/applications/cytoland/examples/configs/recipes/modes/spotlight.yml +++ b/applications/cytoland/examples/configs/recipes/modes/spotlight.yml @@ -1,9 +1,10 @@ # Mode recipe: Spotlight foreground-aware loss (Kalinin et al. 2025). # Cross-cutting: sets loss, fg_mask_key, nonzero filtering, AND -# Otsu-centered normalization. fg_threshold: 0.0 is valid ONLY -# because normalizations use subtrahend: otsu_threshold. +# Otsu-centered normalization. The Otsu-centred target is what makes 0 the +# FG/BG boundary in the model's output space -- which the Dice term needs +# regardless of fg_threshold, since that field is inert here (see below). # -# Requires: viscy preprocess --compute_otsu --compute_fg_masks +# Requires: viscy preprocess --compute_otsu true --compute_fg_masks true # # Base ordering: this mode must come AFTER the data recipe in the # base: list so that its normalizations replace the data default. @@ -14,6 +15,10 @@ model: init_args: lambda_mse: 0.5 sigmoid_k: -0.95 + # INERT while data.fg_mask_key is set below: forward() short-circuits + # on `if fg_mask is not None`, so the mask from the store defines + # foreground and this threshold is never consulted. It applies only if + # fg_mask_key is removed. Same for data.nonzero_threshold. fg_threshold: 0.0 data: init_args: diff --git a/applications/cytoland/examples/configs/vscyto3d/train_spotlight.yml b/applications/cytoland/examples/configs/vscyto3d/train_spotlight.yml index a5cbdd25c..7a423f970 100644 --- a/applications/cytoland/examples/configs/vscyto3d/train_spotlight.yml +++ b/applications/cytoland/examples/configs/vscyto3d/train_spotlight.yml @@ -1,5 +1,5 @@ # VSCyto3D: supervised training with Spotlight foreground-aware loss. -# Requires: viscy preprocess --compute_otsu --compute_fg_masks +# Requires: viscy preprocess --compute_otsu true --compute_fg_masks true # Usage: python -m cytoland fit --config vscyto3d/train_spotlight.yml base: - ../recipes/trainer/fit.yml From f0880a29d9f1773749c8c1673c817ab308b28d34 Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:50:18 -0700 Subject: [PATCH 20/72] docs(cytoland): install the VCP tutorials' unpublished deps from GitHub Port the tutorial fix from d3f6422f (#479): cytoland and viscy-utils are not on PyPI yet, so the tutorials install them from the GitHub monorepo; their siblings resolve from PyPI. Adds the jupytext-paired notebooks (no outputs). Co-Authored-By: Claude Opus 5.5 --- .../examples/vcp_tutorials/hek293t.ipynb | 368 +++++++++++++ .../examples/vcp_tutorials/hek293t.py | 5 +- .../examples/vcp_tutorials/neuromast.ipynb | 465 +++++++++++++++++ .../examples/vcp_tutorials/neuromast.py | 5 +- .../examples/vcp_tutorials/quick_start.ipynb | 492 ++++++++++++++++++ .../examples/vcp_tutorials/quick_start.py | 6 +- 6 files changed, 1335 insertions(+), 6 deletions(-) create mode 100644 applications/cytoland/examples/vcp_tutorials/hek293t.ipynb create mode 100644 applications/cytoland/examples/vcp_tutorials/neuromast.ipynb create mode 100644 applications/cytoland/examples/vcp_tutorials/quick_start.ipynb diff --git a/applications/cytoland/examples/vcp_tutorials/hek293t.ipynb b/applications/cytoland/examples/vcp_tutorials/hek293t.ipynb new file mode 100644 index 000000000..ce81bebf1 --- /dev/null +++ b/applications/cytoland/examples/vcp_tutorials/hek293t.ipynb @@ -0,0 +1,368 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d0990bbc", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Cytoland Tutorial: Virtual Staining of HEK293T Cells with VSCyto3D\n", + "\n", + "**Estimated time to complete:** 15 minutes" + ] + }, + { + "cell_type": "markdown", + "id": "02b87aa0", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Learning Goals\n", + "\n", + "* Download the VSCyto3D model and an example dataset containing HEK293T cell images.\n", + "* Pre-compute normalization statistics for the images using the `viscy preprocess` command line interface (CLI).\n", + "* Run inference for joint virtual staining of cell nuclei and plasma membrane via the `viscy predict` CLI.\n", + "* Compare virtually and experimentally stained cells and see how virtual staining can rescue missing labels." + ] + }, + { + "cell_type": "markdown", + "id": "dc3ac201", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Prerequisites\n", + "\n", + "Python>=3.12" + ] + }, + { + "cell_type": "markdown", + "id": "ff9bed71", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Introduction\n", + "\n", + "See the [model card](https://virtualcellmodels.cziscience.com/paper/cytoland2025)\n", + "for more details about the Cytoland models.\n", + "\n", + "VSCyto3D is a 3D UNeXt2 model that has been trained on A549, HEK293T, and hiPSC cells using the Cytoland approach.\n", + "This model enables users to jointly stain cell nuclei and plasma membranes from 3D label-free images\n", + "for downstream analysis such as cell segmentation and tracking without the need for human annotation of volumetric data." + ] + }, + { + "cell_type": "markdown", + "id": "e96a3709", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Setup\n", + "\n", + "The commands below will install the required packages and download the example dataset and model checkpoint.\n", + "It may take a **few minutes** to download all the files.\n", + "\n", + "## Setup Google Colab\n", + "\n", + "To run this quick-start guide using Google Colab,\n", + "choose the 'T4' GPU runtime from the \"Connect\" dropdown menu\n", + "in the upper-right corner of this notebook for faster execution.\n", + "Using a GPU significantly speeds up running model inference, but CPU compute can also be used.\n", + "\n", + "## Setup Local Environment\n", + "\n", + "The commands below assume a Unix-like shell with `wget` installed.\n", + "On Windows, the files can be downloaded manually from the URLs." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ca08f540", + "metadata": {}, + "outputs": [], + "source": [ + "# Install the modular Cytoland/VisCy packages required for this example\n", + "# `cytoland` and `viscy-utils` are not yet on PyPI, so they are installed from\n", + "# the GitHub monorepo (their siblings resolve from PyPI automatically).\n", + "# Here stackview and ipycanvas are installed for visualization\n", + "!pip install \"viscy-utils @ git+https://github.com/mehta-lab/VisCy.git#subdirectory=packages/viscy-utils\" \"cytoland @ git+https://github.com/mehta-lab/VisCy.git#subdirectory=applications/cytoland\" stackview ipycanvas==0.11" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d5673cf4", + "metadata": {}, + "outputs": [], + "source": [ + "# Restart kernel if running in Google Colab\n", + "# This is required to use the packages installed above\n", + "# The 'kernel crashed' message is expected here\n", + "if \"get_ipython\" in globals():\n", + " session = get_ipython() # noqa: F821\n", + " if \"google.colab\" in str(session):\n", + " print(\"Shutting down colab session.\")\n", + " session.kernel.do_shutdown(restart=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5c70d5e2", + "metadata": {}, + "outputs": [], + "source": [ + "# Download the example dataset\n", + "!wget -m -np -nH --cut-dirs=5 -R \"index.html*\" \"https://public.czbiohub.org/comp.micro/viscy/VS_datasets/VSCyto3D/test/HEK293T-Phase3D-H2B-CAAX-example.zarr/\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fc9db7a0", + "metadata": {}, + "outputs": [], + "source": [ + "# Rename the downloaded dataset to what the example prediction config expects (`input.ome.zarr`)\n", + "# And validate the OME-Zarr metadata with iohub\n", + "!mv HEK293T-Phase3D-H2B-CAAX-example.zarr input.ome.zarr\n", + "!iohub info -v input.ome.zarr" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d2a2d1e7", + "metadata": {}, + "outputs": [], + "source": [ + "# Download the VSCyto3D model checkpoint and prediction config\n", + "!wget \"https://public.czbiohub.org/comp.micro/viscy/VS_models/VSCyto3D/epoch=83-step=14532-loss=0.492.ckpt\"\n", + "!wget \"https://public.czbiohub.org/comp.micro/viscy/VS_models/VSCyto3D/predict.yml\"" + ] + }, + { + "cell_type": "markdown", + "id": "46fdb6cb", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Use Case\n", + "\n", + "## Example Dataset\n", + "\n", + "The HEK293T example dataset used in this quick-start guide contains\n", + "quantitative phase and paired fluorescence images of cell nuclei and plasma membrane.\n", + "It is a subset (one cropped region of interest) from a test set used to evaluate the VSCyto3D model.\n", + "The full dataset can be downloaded from the\n", + "[BioImage Archive](https://www.ebi.ac.uk/biostudies/BioImages/studies/S-BIAD1702).\n", + "\n", + "Refer to our [preprint](https://doi.org/10.1101/2024.05.31.596901) for more details\n", + "about how the dataset and model were generated.\n", + "\n", + "## Using Custom Data\n", + "\n", + "The model only requires label-free images for inference.\n", + "To run inference on your own data,\n", + "convert them into the OME-Zarr data format using iohub or other\n", + "[tools](https://ngff.openmicroscopy.org/tools/index.html#file-conversion),\n", + "and edit the `predict.yml` file to specify the input data path.\n", + "Specifically, the `data.init_args.data_path` field should be updated:\n", + "\n", + "```diff\n", + "- data_path: input.ome.zarr\n", + "+ data_path: /path/to/your.ome.zarr\n", + "```\n", + "\n", + "The image may need to be resampled to roughly match the voxel size of the example dataset\n", + "(0.2x0.1x0.1 µm, ZYX)." + ] + }, + { + "cell_type": "markdown", + "id": "2d84aad9", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Run Model Inference\n", + "\n", + "On Google Colab, the preprocessing step takes about **1 minute**,\n", + "and the inference step takes about **2 minutes** (T4 GPU)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "383fb379", + "metadata": {}, + "outputs": [], + "source": [ + "# Run the CLI command to pre-compute normalization statistics\n", + "# This includes the median and interquartile range (IQR)\n", + "# Used to shift and scale the intensity distribution of the input images\n", + "!viscy preprocess --data_path=input.ome.zarr" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9c324ee5", + "metadata": {}, + "outputs": [], + "source": [ + "# Run the CLI command to run inference\n", + "!viscy predict -c predict.yml" + ] + }, + { + "cell_type": "markdown", + "id": "12de2060", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Analysis of Model Outputs\n", + "\n", + "Visualize the experimental and virtually stained images using the `stackview` package." + ] + }, + { + "cell_type": "markdown", + "id": "a2761744", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "Visualizing large 3D multichannel images in a Jupyter notebook\n", + "**is prone to performance issues and may crash the notebook** if the images are too large\n", + "(the free Colab instances have limited CPU cores and memory).\n", + "The visualization code below is only intended for demonstration.\n", + "We strongly recommend downloading the images (from the 'files' bar in Colab)\n", + "and using a standalone viewer such as [napari](https://napari.org/)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "64176a04", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # noqa: E402\n", + "import stackview # noqa: E402\n", + "from iohub import open_ome_zarr # noqa: E402\n", + "from skimage.exposure import rescale_intensity # noqa: E402\n", + "\n", + "try:\n", + " from google.colab import output\n", + "\n", + " output.enable_custom_widget_manager()\n", + "except ImportError:\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bbb0b4a2", + "metadata": {}, + "outputs": [], + "source": [ + "# open the images\n", + "def split_and_rescale_channels(timepoint: np.ndarray) -> tuple[np.ndarray, ...]:\n", + " return (rescale_intensity(channel, out_range=(0, 1)) for channel in timepoint)\n", + "\n", + "\n", + "fov_name = \"plate/0/11\"\n", + "input_image = open_ome_zarr(\"input.ome.zarr\")[fov_name][\"0\"]\n", + "prediction_image = open_ome_zarr(\"prediction.ome.zarr\")[fov_name][\"0\"]\n", + "\n", + "phase, fluor_nucleus, fluor_membrane = split_and_rescale_channels(input_image[0])\n", + "vs_nucleus, vs_membrane = split_and_rescale_channels(prediction_image[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6c6d3cb4", + "metadata": {}, + "outputs": [], + "source": [ + "# Drag the slider to start rendering\n", + "# Click on the numbered buttons to toggle the channels\n", + "stackview.switch(\n", + " # the 0, 1, 2, 3, 4 buttons will correspond to these 5 channels\n", + " # We apply a gamma adjustment to the phase channel to improve visibility in the overlay\n", + " images=[phase**2.5, fluor_nucleus, fluor_membrane, vs_nucleus, vs_membrane],\n", + " colormap=[\"gray\", \"pure_green\", \"pure_magenta\", \"pure_blue\", \"pure_yellow\"],\n", + " toggleable=True,\n", + " zoom_factor=0.5,\n", + " display_min=0.0,\n", + " display_max=0.9,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "2733926b", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "Note how the experimental fluorescence is missing for a subset of cells.\n", + "This is due to loss of genetic labeling.\n", + "The virtually stained images is not affected by this issue and can robustly label all cells." + ] + }, + { + "cell_type": "markdown", + "id": "a8c347af", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Summary\n", + "\n", + "In the above example, we demonstrated how to use the VSCyto3D model\n", + "for virtual staining of cell nuclei and plasma membranes, which can rescue missing labels." + ] + }, + { + "cell_type": "markdown", + "id": "9063adf6", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## Contact & Feedback\n", + "\n", + "For issues or feedback about this tutorial please contact Ziwen Liu at [ziwen.liu@czbiohub.org](mailto:ziwen.liu@czbiohub.org).\n", + "\n", + "## Responsible Use\n", + "\n", + "We are committed to advancing the responsible development and use of artificial intelligence.\n", + "Please follow our [Acceptable Use Policy](https://virtualcellmodels.cziscience.com/acceptable-use-policy) when engaging with our services.\n", + "\n", + "Should you have any security or privacy issues or questions related to the services,\n", + "please reach out to our team at [security@chanzuckerberg.com](mailto:security@chanzuckerberg.com) or [privacy@chanzuckerberg.com](mailto:privacy@chanzuckerberg.com) respectively." + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "all", + "main_language": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/applications/cytoland/examples/vcp_tutorials/hek293t.py b/applications/cytoland/examples/vcp_tutorials/hek293t.py index d318ff895..2d66762f6 100644 --- a/applications/cytoland/examples/vcp_tutorials/hek293t.py +++ b/applications/cytoland/examples/vcp_tutorials/hek293t.py @@ -56,9 +56,10 @@ # %% # Install the modular Cytoland/VisCy packages required for this example -# See the [repository](https://github.com/mehta-lab/VisCy) for more details +# `cytoland` and `viscy-utils` are not yet on PyPI, so they are installed from +# the GitHub monorepo (their siblings resolve from PyPI automatically). # Here stackview and ipycanvas are installed for visualization -# !pip install -U cytoland viscy stackview ipycanvas==0.11 +# !pip install "viscy-utils @ git+https://github.com/mehta-lab/VisCy.git#subdirectory=packages/viscy-utils" "cytoland @ git+https://github.com/mehta-lab/VisCy.git#subdirectory=applications/cytoland" stackview ipycanvas==0.11 # %% # Restart kernel if running in Google Colab diff --git a/applications/cytoland/examples/vcp_tutorials/neuromast.ipynb b/applications/cytoland/examples/vcp_tutorials/neuromast.ipynb new file mode 100644 index 000000000..e66db361d --- /dev/null +++ b/applications/cytoland/examples/vcp_tutorials/neuromast.ipynb @@ -0,0 +1,465 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2dd42bb7", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Cytoland Tutorial: Virtual Staining of Zebrafish Neuromasts with VSNeuromast\n", + "\n", + "**Estimated time to complete:** 15 minutes" + ] + }, + { + "cell_type": "markdown", + "id": "e1c38b9f", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Learning Goals\n", + "\n", + "* Download the VSNeuromast model and an example dataset containing time-lapse images of zebrafish neuromasts.\n", + "* Pre-compute normalization statistics for the images using the `viscy preprocess` command-line interface (CLI).\n", + "* Run inference for joint virtual staining of cell nuclei and plasma membrane via the `viscy predict` CLI.\n", + "* Visualize the effect of photobleaching in fluorescence imaging and how virtual staining can mitigate this issue." + ] + }, + { + "cell_type": "markdown", + "id": "c1aa6808", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Prerequisites\n", + "\n", + "Python>=3.12" + ] + }, + { + "cell_type": "markdown", + "id": "bd3b93d4", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Introduction\n", + "\n", + "The zebrafish neuromasts are sensory organs on the lateral lines.\n", + "Given their relatively simple structure and high accessibility to live imaging,\n", + "they are used as a model system to study organogenesis _in vivo_.\n", + "However, multiplexed long-term fluorescence imaging at high spatial-temporal resolution\n", + "is often limited by photobleaching and phototoxicity.\n", + "Also, engineering fish lines with a combination of landmark fluorescent labels\n", + "(e.g. nuclei and plasma membrane) and functional reporters increases experimental complexity.\n", + "\\\n", + "VSNeuromast is a 3D UNeXt2 model that has been trained on images of\n", + "zebrafish neuromasts using the Cytoland approach.\n", + "(See the [model card](https://virtualcellmodels.cziscience.com/paper/cytoland2025)\n", + "for more details about the Cytoland models.)\n", + "This model enables users to jointly stain cell nuclei and plasma membranes from 3D label-free images\n", + "for downstream analysis such as cell segmentation and tracking." + ] + }, + { + "cell_type": "markdown", + "id": "f2a6edfe", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Setup\n", + "\n", + "The commands below will install the required packages and download the example dataset and model checkpoint.\n", + "It may take a **few minutes** to download all the files.\n", + "\n", + "## Setup Google Colab\n", + "\n", + "To run this quick-start guide using Google Colab,\n", + "choose the 'T4' GPU runtime from the \"Connect\" dropdown menu\n", + "in the upper-right corner of this notebook for faster execution.\n", + "Using a GPU significantly speeds up running model inference, but CPU compute can also be used.\n", + "\n", + "## Setup Local Environment\n", + "\n", + "The commands below assume a Unix-like shell with `wget` installed.\n", + "On Windows, the files can be downloaded manually from the URLs." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d3f0a34a", + "metadata": {}, + "outputs": [], + "source": [ + "# Install the modular Cytoland/VisCy packages required for this example\n", + "# `cytoland` and `viscy-utils` are not yet on PyPI, so they are installed from\n", + "# the GitHub monorepo (their siblings resolve from PyPI automatically).\n", + "# Here stackview and ipycanvas are installed for visualization, and iohub provides OME-Zarr access\n", + "!pip install \"viscy-utils @ git+https://github.com/mehta-lab/VisCy.git#subdirectory=packages/viscy-utils\" \"cytoland @ git+https://github.com/mehta-lab/VisCy.git#subdirectory=applications/cytoland\" iohub stackview ipycanvas" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "540ab976", + "metadata": {}, + "outputs": [], + "source": [ + "# Restart kernel if running in Google Colab\n", + "# This is required to use the packages installed above\n", + "# The 'kernel crashed' message is expected here\n", + "if \"get_ipython\" in globals():\n", + " session = get_ipython()\n", + " if \"google.colab\" in str(session):\n", + " print(\"Shutting down colab session.\")\n", + " session.kernel.do_shutdown(restart=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "51cf0bab", + "metadata": {}, + "outputs": [], + "source": [ + "# Download the example dataset\n", + "!wget -m -np -nH --cut-dirs=5 -R \"index.html*\" \"https://public.czbiohub.org/comp.micro/viscy/VS_datasets/VSNeuromast/test/isim-bleaching-example.zarr/\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "250def65", + "metadata": {}, + "outputs": [], + "source": [ + "# Rename the downloaded dataset to what the example prediction config expects (`input.ome.zarr`)\n", + "# And validate the OME-Zarr metadata with iohub\n", + "!mv isim-bleaching-example.zarr input.ome.zarr\n", + "!iohub info -v input.ome.zarr" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88326661", + "metadata": {}, + "outputs": [], + "source": [ + "# Download the VSNeuromast model checkpoint and prediction config\n", + "!wget \"https://public.czbiohub.org/comp.micro/viscy/VS_models/VSNeuromast/epoch=64-step=24960.ckpt\"\n", + "!wget \"https://public.czbiohub.org/comp.micro/viscy/VS_models/VSNeuromast/predict.yml\"" + ] + }, + { + "cell_type": "markdown", + "id": "1022e0e7", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Use Case\n", + "\n", + "## Example Dataset\n", + "\n", + "The neuromast example dataset used in this tutorial contains\n", + "quantitative phase and paired fluorescence images of the cell nuclei and the plasma membrane.\n", + "\\\n", + "**It is a subsampled time-lapse from a test set used to evaluate the VSNeuromast model.**\n", + "\\\n", + "The full dataset can be downloaded from the\n", + "[BioImage Archive](https://www.ebi.ac.uk/biostudies/BioImages/studies/S-BIAD1702).\n", + "\n", + "Refer to our [preprint](https://doi.org/10.1101/2024.05.31.596901) for more details\n", + "about how the dataset and model were generated.\n", + "\n", + "## Using Custom Data\n", + "\n", + "The model only requires label-free images for inference.\n", + "To run inference on your own data,\n", + "convert them into the [OME-Zarr](https://ngff.openmicroscopy.org/)\n", + "data format using iohub or other\n", + "[tools](https://ngff.openmicroscopy.org/tools/index.html#file-conversion),\n", + "and edit the `predict.yml` file to specify the input data path.\n", + "Specifically, the `data.init_args.data_path` field should be updated:\n", + "\n", + "```diff\n", + "- data_path: input.ome.zarr\n", + "+ data_path: /path/to/your.ome.zarr\n", + "```\n", + "\n", + "The image may need to be resampled to roughly match the voxel size of the example dataset\n", + "(0.25x0.108x0.108 µm, ZYX)." + ] + }, + { + "cell_type": "markdown", + "id": "a7482dd5", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Run Model Inference\n", + "\n", + "On Google Colab, the preprocessing step takes about **1 minute**,\n", + "and the inference step takes about **2 minutes** (T4 GPU)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2df952e4", + "metadata": {}, + "outputs": [], + "source": [ + "# Run the CLI command to pre-compute normalization statistics\n", + "# This includes the median and interquartile range (IQR)\n", + "# Used to shift and scale the intensity distribution of the input images\n", + "!viscy preprocess --data_path=input.ome.zarr" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "05021fa5", + "metadata": {}, + "outputs": [], + "source": [ + "# Run the CLI command to run inference\n", + "!viscy predict -c predict.yml" + ] + }, + { + "cell_type": "markdown", + "id": "11adee29", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Analysis of Model Outputs\n", + "\n", + "1. Visualize predicted images over time and compare with the fluorescence images.\n", + "2. Measure photobleaching in the fluorescence images\n", + "and how virtual staining can mitigate this issue.\n", + "Since most pixels in the images are background,\n", + "we will use the 99th percentile (brightest 1%)\n", + "of the intensity distribution as a proxy for foreground signal." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3dab72b1", + "metadata": {}, + "outputs": [], + "source": [ + "# imports\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from cmap import Colormap\n", + "from iohub import open_ome_zarr\n", + "from numpy.typing import NDArray\n", + "from skimage.exposure import rescale_intensity\n", + "\n", + "\n", + "def render_rgb(image: np.ndarray, colormap: Colormap) -> tuple[NDArray, plt.cm.ScalarMappable]:\n", + " \"\"\"Render a 2D grayscale image as RGB using a colormap.\n", + "\n", + " Parameters\n", + " ----------\n", + " image : np.ndarray\n", + " intensity image\n", + " colormap : Colormap\n", + " colormap\n", + "\n", + " Returns\n", + " -------\n", + " tuple[NDArray, plt.cm.ScalarMappable]\n", + " rendered RGB image and the color mapping\n", + " \"\"\"\n", + " image = rescale_intensity(image, out_range=(0, 1))\n", + " image = colormap(image)\n", + " mappable = plt.cm.ScalarMappable(norm=plt.Normalize(0, 1), cmap=colormap.to_matplotlib())\n", + " return image, mappable" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "108cfd0c", + "metadata": {}, + "outputs": [], + "source": [ + "# read a single Z-slice for visualization\n", + "z_slice = 30\n", + "\n", + "with open_ome_zarr(\"input.ome.zarr/0/3/0\") as fluor_store:\n", + " fluor_nucleus = fluor_store[0][:, 1, z_slice]\n", + " fluor_membrane = fluor_store[0][:, 0, z_slice]\n", + "\n", + "with open_ome_zarr(\"prediction.ome.zarr/0/3/0\") as vs_store:\n", + " vs_nucleus = vs_store[0][:, 0, z_slice]\n", + " vs_membrane = vs_store[0][:, 1, z_slice]\n", + "\n", + "\n", + "# Render the images as RGB in false colors\n", + "vs_nucleus_rgb, vs_nucleus_mappable = render_rgb(vs_nucleus, Colormap(\"bop_blue\"))\n", + "vs_membrane_rgb, vs_membrane_mappable = render_rgb(vs_membrane, Colormap(\"bop_orange\"))\n", + "merged_vs = (vs_nucleus_rgb + vs_membrane_rgb).clip(0, 1)\n", + "\n", + "fluor_nucleus_rgb, fluor_nucleus_mappable = render_rgb(fluor_nucleus, Colormap(\"green\"))\n", + "fluor_membrane_rgb, fluor_membrane_mappable = render_rgb(fluor_membrane, Colormap(\"magenta\"))\n", + "merged_fluor = (fluor_nucleus_rgb + fluor_membrane_rgb).clip(0, 1)\n", + "\n", + "# Plot\n", + "fig = plt.figure(figsize=(12, 7), layout=\"constrained\")\n", + "\n", + "images = {\"fluorescence\": merged_fluor, \"virtual staining\": merged_vs}\n", + "\n", + "for row, (subfig, (name, img)) in enumerate(zip(fig.subfigures(nrows=2, ncols=1), images.items())):\n", + " subfig.suptitle(name)\n", + " cax_nuc = subfig.add_axes([1, 0.55, 0.02, 0.3])\n", + " cax_mem = subfig.add_axes([1, 0.15, 0.02, 0.3])\n", + " axes = subfig.subplots(ncols=len(merged_vs))\n", + " for t, ax in enumerate(axes):\n", + " if row == 1:\n", + " ax.set_title(f\"{t * 30} min\", y=-0.1)\n", + " ax.imshow(img[t])\n", + " ax.axis(\"off\")\n", + " if row == 0:\n", + " subfig.colorbar(fluor_nucleus_mappable, cax=cax_nuc, label=\"Nuclei (GFP)\")\n", + " subfig.colorbar(fluor_membrane_mappable, cax=cax_mem, label=\"Membrane (mScarlett)\")\n", + " elif row == 1:\n", + " subfig.colorbar(vs_nucleus_mappable, cax=cax_nuc, label=\"Nuclei (VS)\")\n", + " subfig.colorbar(vs_membrane_mappable, cax=cax_mem, label=\"Membrane (VS)\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5fcd7a29", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "The plasma membrane fluorescence decreases over time,\n", + "while the virtual staining remains stable.\n", + "How significant is this effect? Is it consistent with photobleaching?\n", + "Analysis below will answer these questions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "452ba89e", + "metadata": {}, + "outputs": [], + "source": [ + "def highlight_intensity_normalized(fov_path: str, channel_name: str) -> list[float]:\n", + " \"\"\"\n", + " Compute highlight (99th percentile) intensity of each timepoint,\n", + " normalized to the first timepoint.\n", + "\n", + " Parameters\n", + " ----------\n", + " fov_path : str\n", + " Path to the field of view (FOV).\n", + " channel_name : str\n", + " Name of the channel to compute highlight intensity for.\n", + "\n", + " Returns\n", + " -------\n", + " NDArray\n", + " List of intensity values.\n", + " \"\"\"\n", + " with open_ome_zarr(fov_path) as fov:\n", + " channel_index = fov.get_channel_index(channel_name)\n", + " channel = fov[\"0\"].dask_array()[:, channel_index]\n", + " highlights = []\n", + " for t, volume in enumerate(channel):\n", + " highlights.append(np.percentile(volume.compute(), 99))\n", + " return [h / highlights[0] for h in highlights]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "837be184", + "metadata": {}, + "outputs": [], + "source": [ + "# Plot intensity over time\n", + "mean_fl = highlight_intensity_normalized(\"input.ome.zarr/0/3/0\", \"mScarlett\")\n", + "mean_vs = highlight_intensity_normalized(\"prediction.ome.zarr/0/3/0\", \"membrane_prediction\")\n", + "time = np.arange(0, 100, 30)\n", + "\n", + "plt.plot(time, mean_fl, label=\"membrane fluorescence\")\n", + "plt.plot(time, mean_vs, label=\"membrane virtual staining\")\n", + "plt.xlabel(\"time / min\")\n", + "plt.ylabel(\"normalized highlight intensity\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "00d41be6", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "Here the highlight intensity of the fluorescence images decreases over time,\n", + "following a exponential decay pattern, indicating photobleaching.\n", + "The virtual staining is not affected by this issue.\n", + "(The object drifts slightly over time, so some inherent noise is expected.)" + ] + }, + { + "cell_type": "markdown", + "id": "19bb6b01", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Summary\n", + "\n", + "In the above example, we demonstrated how to use the VSNeuromast model\n", + "for virtual staining of cell nuclei and plasma membranes of the zebrafish neuromast _in vivo_,\n", + "which can avoid photobleaching in long-term live imaging." + ] + }, + { + "cell_type": "markdown", + "id": "8bda5ac2", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## Contact & Feedback\n", + "\n", + "For issues or feedback about this tutorial please contact Ziwen Liu at [ziwen.liu@czbiohub.org](mailto:ziwen.liu@czbiohub.org).\n", + "\n", + "## Responsible Use\n", + "\n", + "We are committed to advancing the responsible development and use of artificial intelligence.\n", + "Please follow our [Acceptable Use Policy](https://virtualcellmodels.cziscience.com/acceptable-use-policy) when engaging with our services.\n", + "\n", + "Should you have any security or privacy issues or questions related to the services,\n", + "please reach out to our team at [security@chanzuckerberg.com](mailto:security@chanzuckerberg.com) or [privacy@chanzuckerberg.com](mailto:privacy@chanzuckerberg.com) respectively." + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "all", + "main_language": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/applications/cytoland/examples/vcp_tutorials/neuromast.py b/applications/cytoland/examples/vcp_tutorials/neuromast.py index a65d305ea..d88ab659c 100644 --- a/applications/cytoland/examples/vcp_tutorials/neuromast.py +++ b/applications/cytoland/examples/vcp_tutorials/neuromast.py @@ -64,9 +64,10 @@ # %% # Install the modular Cytoland/VisCy packages required for this example -# See the [repository](https://github.com/mehta-lab/VisCy) for more details +# `cytoland` and `viscy-utils` are not yet on PyPI, so they are installed from +# the GitHub monorepo (their siblings resolve from PyPI automatically). # Here stackview and ipycanvas are installed for visualization, and iohub provides OME-Zarr access -# !pip install -U cytoland viscy iohub stackview ipycanvas +# !pip install "viscy-utils @ git+https://github.com/mehta-lab/VisCy.git#subdirectory=packages/viscy-utils" "cytoland @ git+https://github.com/mehta-lab/VisCy.git#subdirectory=applications/cytoland" iohub stackview ipycanvas # %% # Restart kernel if running in Google Colab diff --git a/applications/cytoland/examples/vcp_tutorials/quick_start.ipynb b/applications/cytoland/examples/vcp_tutorials/quick_start.ipynb new file mode 100644 index 000000000..5c4726fb2 --- /dev/null +++ b/applications/cytoland/examples/vcp_tutorials/quick_start.ipynb @@ -0,0 +1,492 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9421d8c7", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Quick Start: Cytoland\n", + "\n", + "**Estimated time to complete:** 15 minutes" + ] + }, + { + "cell_type": "markdown", + "id": "7dae3dc1", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Learning Goals\n", + "\n", + "* Download the VSCyto2D model and an example dataset containing A549 cell images.\n", + "* Run VSCyto2D model inference for joint virtual staining of cell nuclei and plasma membrane.\n", + "* Visualize and compare virtually and experimentally stained cells." + ] + }, + { + "cell_type": "markdown", + "id": "b86f7719", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Prerequisites\n", + "Python>=3.12" + ] + }, + { + "cell_type": "markdown", + "id": "23c78bc5", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Introduction\n", + "\n", + "## Model\n", + "\n", + "The Cytoland virtual staining models are a collection of models (VSCyto2D, VSCyto3D, and VSNeuromast)\n", + "used to predict cellular landmarks (e.g., nuclei and plasma membranes)\n", + "from label-free images (e.g. quantitative phase, Zernike phase contrast, and brightfield).\n", + "This quick-start guide focuses on the VSCyto2D model.\n", + "\n", + "VSCyto2D is a 2D UNeXt2 model that has been trained on A549, HEK293T, and BJ-5ta cells.\n", + "This model enables users to jointly stain cell nuclei and plasma membranes from 2D label-free images\n", + "that are commonly generated for image-based screens.\n", + "\n", + "Alternative models are optimized for different sample types and imaging conditions:\n", + "\n", + "* [VSCyto3D](https://public.czbiohub.org/comp.micro/viscy/VS_models/VSCyto3D):\n", + "3D UNeXt2 model for joint virtual staining of cell nuclei and plasma membrane\n", + "from high-resolution volumetric images.\n", + "* [VSNeuromast](https://public.czbiohub.org/comp.micro/viscy/VS_models/VSNeuromast):\n", + "3D UNeXt2 model for joint virtual staining of nuclei and plasma membrane in zebrafish neuromasts.\n", + "\n", + "## Example Dataset\n", + "\n", + "The A549 example dataset used in this quick-start guide contains\n", + "quantitative phase and paired fluorescence images of cell nuclei and plasma membrane.\n", + "It is stored in OME-Zarr format and can be downloaded from\n", + "[here](https://public.czbiohub.org/comp.micro/viscy/VS_datasets/VSCyto2D/test/a549_hoechst_cellmask_test.zarr).\n", + "It has pre-computed statistics for normalization, generated using the `viscy preprocess` CLI.\n", + "\n", + "Refer to our [preprint](https://doi.org/10.1101/2024.05.31.596901) for more details\n", + "about how the dataset and model were generated.\n", + "\n", + "## User Data\n", + "\n", + "The VSCyto2D model only requires label-free images for inference.\n", + "To run inference on your own data,\n", + "convert them into the OME-Zarr data format using iohub or other\n", + "[tools](https://ngff.openmicroscopy.org/tools/index.html#file-conversion),\n", + "and run [pre-processing](https://github.com/mehta-lab/VisCy/blob/main/docs/usage.md#preprocessing)\n", + "with the `viscy preprocess` CLI." + ] + }, + { + "cell_type": "markdown", + "id": "aba74cd8", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Setup\n", + "\n", + "The commands below will install the required packages and download the example dataset and model checkpoint.\n", + "It may take a few minutes to download all the files.\n", + "\n", + "## Setup Google Colab\n", + "\n", + "To run this quick-start guide using Google Colab,\n", + "choose the 'T4' GPU runtime from the \"Connect\" dropdown menu\n", + "in the upper-right corner of this notebook for faster execution.\n", + "Using a GPU significantly speeds up running model inference, but CPU compute can also be used.\n", + "\n", + "## Setup Local Environment\n", + "\n", + "The commands below assume a Unix-like shell with `wget` installed.\n", + "On Windows, the files can be downloaded manually from the URLs." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "069fbda0", + "metadata": {}, + "outputs": [], + "source": [ + "# Install the modular packages required for this example\n", + "# `cytoland` and `viscy-utils` are not yet published to PyPI, so they are\n", + "# installed from the GitHub monorepo; their siblings (viscy-data, viscy-models,\n", + "# viscy-transforms) resolve from PyPI automatically.\n", + "!pip install \"viscy-utils @ git+https://github.com/mehta-lab/VisCy.git#subdirectory=packages/viscy-utils\" \"cytoland @ git+https://github.com/mehta-lab/VisCy.git#subdirectory=applications/cytoland\" torchview cmap iohub" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "44132e97", + "metadata": {}, + "outputs": [], + "source": [ + "# restart kernel if running in Google Colab\n", + "if \"get_ipython\" in globals():\n", + " session = get_ipython() # noqa: F821\n", + " if \"google.colab\" in str(session):\n", + " print(\"Shutting down colab session.\")\n", + " session.kernel.do_shutdown(restart=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4c898fe", + "metadata": {}, + "outputs": [], + "source": [ + "# Validate installation\n", + "!viscy --help" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4e695f9", + "metadata": {}, + "outputs": [], + "source": [ + "# Download the example dataset\n", + "!wget -m -np -nH --cut-dirs=5 -R \"index.html*\" \"https://public.czbiohub.org/comp.micro/viscy/VS_datasets/VSCyto2D/test/a549_hoechst_cellmask_test.zarr/\"\n", + "# Download the model checkpoint\n", + "!wget https://public.czbiohub.org/comp.micro/viscy/VS_models/VSCyto2D/VSCyto2D/epoch=399-step=23200.ckpt" + ] + }, + { + "cell_type": "markdown", + "id": "dc8ccda1", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Run Model Inference\n", + "\n", + "The following code will run inference on a single field of view (FOV) of the example dataset.\n", + "This can also be achieved by using the VisCy CLI." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8ad5bdd8", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path # noqa: E402\n", + "\n", + "from iohub import open_ome_zarr # noqa: E402\n", + "from torchview import draw_graph # noqa: E402\n", + "\n", + "from cytoland.engine import FcmaeUNet # noqa: E402\n", + "from viscy_data.hcs import HCSDataModule # noqa: E402\n", + "from viscy_transforms import NormalizeSampled # noqa: E402\n", + "from viscy_utils.callbacks import HCSPredictionWriter # noqa: E402\n", + "from viscy_utils.trainer import VisCyTrainer # noqa: E402" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "34663450", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "# NOTE: Nothing needs to be changed in this code block for the example to work.\n", + "# If using your own data, please modify the paths below.\n", + "\n", + "# TODO: Set download paths, by default the working directory is used\n", + "root_dir = Path()\n", + "# TODO: modify the path to the input dataset\n", + "input_data_path = root_dir / \"a549_hoechst_cellmask_test.zarr\"\n", + "# TODO: modify the path to the model checkpoint\n", + "model_ckpt_path = root_dir / \"epoch=399-step=23200.ckpt\"\n", + "# TODO: modify the path to save the predictions\n", + "output_path = root_dir / \"a549_prediction.zarr\"\n", + "# TODO: Choose an FOV\n", + "fov = \"0/0/0\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5ff5bd62", + "metadata": {}, + "outputs": [], + "source": [ + "# Configure the data module for loading example images in prediction mode.\n", + "# See API documentation for how to use it with a different dataset.\n", + "# For example, View the documentation for the HCSDataModule class by running:\n", + "?HCSDataModule" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4bb5e84f", + "metadata": {}, + "outputs": [], + "source": [ + "# Setup the data module to use the example dataset\n", + "data_module = HCSDataModule(\n", + " # Path to HCS or Single-FOV OME-Zarr dataset\n", + " data_path=input_data_path / fov,\n", + " # Name of the input phase channel\n", + " source_channel=\"Phase3D\",\n", + " # Desired name of the output channels\n", + " target_channel=[\"Nuclei\", \"Membrane\"],\n", + " # Axial input size, 1 for 2D models\n", + " z_window_size=1,\n", + " # Batch size\n", + " # Adjust based on available memory (reduce if seeing OOM errors)\n", + " batch_size=8,\n", + " # Number of workers for data loading\n", + " # Set to 0 for Windows and macOS if running in a notebook,\n", + " # since multiprocessing only works with a `if __name__ == '__main__':` guard.\n", + " # On Linux, set it based on available CPU cores to maximize performance.\n", + " num_workers=4,\n", + " # Normalization strategy\n", + " # This one uses pre-computed statistics from `viscy preprocess`\n", + " # to subtract the median and divide by the interquartile range (IQR).\n", + " # It can also be replaced by other MONAI transforms.\n", + " normalizations=[\n", + " NormalizeSampled(\n", + " [\"Phase3D\"],\n", + " level=\"fov_statistics\",\n", + " subtrahend=\"median\",\n", + " divisor=\"iqr\",\n", + " )\n", + " ],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5a5b229a", + "metadata": {}, + "outputs": [], + "source": [ + "# Load the VSCyto2D model from the downloaded checkpoint\n", + "# VSCyto2D is fine-tuned from a FCMAE-pretrained UNeXt2 model.\n", + "# See this module for options to configure the model:\n", + "\n", + "?FullyConvolutionalMAE" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "10674ebf", + "metadata": {}, + "outputs": [], + "source": [ + "vs_cyto_2d = FcmaeUNet.load_from_checkpoint(\n", + " # checkpoint path\n", + " model_ckpt_path,\n", + " model_config={\n", + " # number of input channels\n", + " # must match the number of channels in the input data\n", + " \"in_channels\": 1,\n", + " # number of output channels\n", + " # must match the number of target channels in the data module\n", + " \"out_channels\": 2,\n", + " # number of ConvNeXt v2 blocks in each stage of the encoder\n", + " \"encoder_blocks\": [3, 3, 9, 3],\n", + " # feature map channels in each stage of the encoder\n", + " \"dims\": [96, 192, 384, 768],\n", + " # number of ConvNeXt v2 blocks in each stage of the decoder\n", + " \"decoder_conv_blocks\": 2,\n", + " # kernel size in the stem layer\n", + " \"stem_kernel_size\": [1, 2, 2],\n", + " # axial size of the input image\n", + " # must match the Z-window size in the data module\n", + " \"in_stack_depth\": 1,\n", + " # whether to perform masking (for FCMAE pre-training)\n", + " \"pretraining\": False,\n", + " },\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b9cbece7", + "metadata": {}, + "outputs": [], + "source": [ + "# Visualize the model graph\n", + "model_graph = draw_graph(\n", + " vs_cyto_2d,\n", + " (vs_cyto_2d.example_input_array),\n", + " graph_name=\"VSCyto2D\",\n", + " roll=True,\n", + " depth=3,\n", + " expand_nested=True,\n", + ")\n", + "\n", + "model_graph.visual_graph" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e284524b", + "metadata": {}, + "outputs": [], + "source": [ + "# Setup the trainer for prediction\n", + "# The trainer can be further configured to better utilize the available hardware,\n", + "# For example using GPUs and half precision.\n", + "# Callbacks can also be used to customize logging and prediction writing.\n", + "# See the API documentation for more details:\n", + "?VisCyTrainer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bffe587d", + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize the trainer\n", + "# The prediction writer callback will save the predictions to an OME-Zarr store\n", + "trainer = VisCyTrainer(callbacks=[HCSPredictionWriter(output_path)])\n", + "\n", + "# Run prediction\n", + "trainer.predict(model=vs_cyto_2d, datamodule=data_module, return_predictions=False)" + ] + }, + { + "cell_type": "markdown", + "id": "92396f37", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "# Model Outputs\n", + "\n", + "The model outputs are also stored in an OME-Zarr store.\n", + "It can be visualized in an image viewer such as [napari](https://napari.org/).\n", + "Below we show a snapshot in the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "19e90a39", + "metadata": {}, + "outputs": [], + "source": [ + "# Read images from Zarr stores\n", + "# Choose the ROI for better visualization\n", + "y_slice = slice(0, 512)\n", + "x_slice = slice(0, 512)\n", + "\n", + "# Open the prediction store and get the 2D images from 5D arrays (t,c,z,y,x)\n", + "with open_ome_zarr(output_path / fov) as vs_store:\n", + " vs_nucleus = vs_store[0][0, 0, 0, y_slice, x_slice]\n", + " vs_membrane = vs_store[0][0, 1, 0, y_slice, x_slice]\n", + "\n", + "# Open the experimental fluorescence dataset\n", + "with open_ome_zarr(input_data_path / fov) as fluor_store:\n", + " fluor_nucleus = fluor_store[0][0, 1, 0, y_slice, x_slice]\n", + " fluor_membrane = fluor_store[0][0, 2, 0, y_slice, x_slice]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "41ef52ea", + "metadata": {}, + "outputs": [], + "source": [ + "# Plot\n", + "import matplotlib.pyplot as plt # noqa: E402\n", + "import numpy as np # noqa: E402\n", + "from cmap import Colormap # noqa: E402\n", + "from skimage.exposure import rescale_intensity # noqa: E402\n", + "\n", + "\n", + "def render_rgb(image: np.ndarray, colormap: Colormap):\n", + " image = rescale_intensity(image, out_range=(0, 1))\n", + " image = colormap(image)\n", + " return image\n", + "\n", + "\n", + "# Render the images as RGB in false colors\n", + "vs_nucleus_rgb = render_rgb(vs_nucleus, Colormap(\"bop_blue\"))\n", + "vs_membrane_rgb = render_rgb(vs_membrane, Colormap(\"bop_orange\"))\n", + "merged_vs = (vs_nucleus_rgb + vs_membrane_rgb).clip(0, 1)\n", + "\n", + "fluor_nucleus_rgb = render_rgb(fluor_nucleus, Colormap(\"green\"))\n", + "fluor_membrane_rgb = render_rgb(fluor_membrane, Colormap(\"magenta\"))\n", + "merged_fluor = (fluor_nucleus_rgb + fluor_membrane_rgb).clip(0, 1)\n", + "\n", + "# Plot\n", + "# Show the individual channels and then fused in a grid\n", + "fig, ax = plt.subplots(2, 3, figsize=(15, 10))\n", + "\n", + "# Virtual staining plots\n", + "ax[0, 0].imshow(vs_nucleus_rgb)\n", + "ax[0, 0].set_title(\"VS Nuclei\")\n", + "ax[0, 1].imshow(vs_membrane_rgb)\n", + "ax[0, 1].set_title(\"VS Membrane\")\n", + "ax[0, 2].imshow(merged_vs)\n", + "ax[0, 2].set_title(\"VS Nuclei+Membrane\")\n", + "\n", + "# Experimental fluorescence plots\n", + "ax[1, 0].imshow(fluor_nucleus_rgb)\n", + "ax[1, 0].set_title(\"Experimental Fluorescence Nuclei\")\n", + "ax[1, 1].imshow(fluor_membrane_rgb)\n", + "ax[1, 1].set_title(\"Experimental Fluorescence Membrane\")\n", + "ax[1, 2].imshow(merged_fluor)\n", + "ax[1, 2].set_title(\"Experimental Fluorescence Nuclei+Membrane\")\n", + "\n", + "# turnoff axis\n", + "for a in ax.flatten():\n", + " a.axis(\"off\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "bc8778c1", + "metadata": { + "cell_marker": "\"\"\"" + }, + "source": [ + "## Responsible Use\n", + "\n", + "We are committed to advancing the responsible development and use of artificial intelligence.\n", + "Please follow our [Acceptable Use Policy](https://virtualcellmodels.cziscience.com/acceptable-use-policy) when engaging with our services.\n", + "\n", + "Should you have any security or privacy issues or questions related to the services,\n", + "please reach out to our team at [security@chanzuckerberg.com](mailto:security@chanzuckerberg.com) or [privacy@chanzuckerberg.com](mailto:privacy@chanzuckerberg.com) respectively." + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "all", + "main_language": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/applications/cytoland/examples/vcp_tutorials/quick_start.py b/applications/cytoland/examples/vcp_tutorials/quick_start.py index d67a3545f..7f1dc3c74 100644 --- a/applications/cytoland/examples/vcp_tutorials/quick_start.py +++ b/applications/cytoland/examples/vcp_tutorials/quick_start.py @@ -87,8 +87,10 @@ # %% # Install the modular packages required for this example -# See the repositories/package indexes for the latest compatibility details -# !pip install cytoland viscy_data viscy_transforms viscy_utils torchview cmap iohub +# `cytoland` and `viscy-utils` are not yet published to PyPI, so they are +# installed from the GitHub monorepo; their siblings (viscy-data, viscy-models, +# viscy-transforms) resolve from PyPI automatically. +# !pip install "viscy-utils @ git+https://github.com/mehta-lab/VisCy.git#subdirectory=packages/viscy-utils" "cytoland @ git+https://github.com/mehta-lab/VisCy.git#subdirectory=applications/cytoland" torchview cmap iohub # %% # restart kernel if running in Google Colab From cff98a353f43b15044293255db769c0a07c5a59a Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:50:27 -0700 Subject: [PATCH 21/72] docs: cut CLAUDE.md content the code or global memory already states Port 93ac2343 from dynacell-models: drop the repo-layout tree, setup and common-command blocks, lint/docstring rules (pyproject.toml is the source) and the generic coding-philosophy sections. The DynaCell job runbook from the same file arrives with the dynacell PR, since it documents tools that only exist there. Co-Authored-By: Claude Opus 5.5 --- CLAUDE.md | 72 +++---------------------------------------------------- 1 file changed, 3 insertions(+), 69 deletions(-) diff --git a/CLAUDE.md b/CLAUDE.md index d83a7e6f4..cb0afc6bf 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -4,19 +4,7 @@ VisCy is a **uv workspace monorepo** for virtual staining and computational microscopy. Sub-packages live under `packages/`. -## Repo Layout - -``` -pyproject.toml # Root config (ruff, pytest, uv workspace) -packages/ - viscy-data/ # Data loading and Lightning DataModules - viscy-models/ # Neural network architectures - viscy-transforms/ # Image transforms -src/viscy/ # Umbrella package (re-exports) -applications/ # Self-contained research applications -``` - -### Packages vs Applications +## Packages vs Applications - **Shared code belongs in `packages/`**, not in applications. - **Applications must not import from each other.** If two applications need the same logic, move it to an existing package or create a new one. @@ -30,16 +18,6 @@ applications/ # Self-contained research applications Use `uv` package manager. Run commands with `uv run `. Edit `pyproject.toml` to modify dependencies and sync to update `uv.lock`. -```sh -uv venv -p 3.13 -uv sync --all-packages --all-extras -``` - -If `uv` is not installed: -```sh -curl -LsSf https://astral.sh/uv/install.sh | sh -``` - On HPC, symlink the uv cache out of your home directory first: ```sh mkdir -p /hpc/mydata/firstname.lastname/.cache/uv && ln -s /hpc/mydata/firstname.lastname/.cache/uv ~/.cache/uv @@ -98,23 +76,8 @@ Examples (verified against the `applications/dynacell/configs/benchmarks/virtual When in doubt, read both `train_dataloader` overrides directly — they are short. Don't infer from comments alone. -### Common Commands - -```sh -uvx ruff check packages/ # lint -uvx ruff check --fix packages/ # lint + auto-fix -uvx ruff format packages/ # format -uv run pytest # all tests -``` - ### Testing -```sh -uv run pytest # all tests -uv run pytest packages/viscy-data/ # single package (data) -uv run pytest packages/viscy-models/ # single package (models) -``` - Prefer `{file}_test.py` in the same directory as `{file}.py`, unless there are import issues, in which case use `tests/`. Run the suite in parallel with `pytest -n ` (pytest-xdist, in the `test` group). The root `conftest.py` pins each worker to one OpenMP/BLAS thread. Without that pin, torch in every worker grabs every core and the parallel run is 10x slower than it should be. `-n auto` counts the cores the shell may use, so inside a 1-CPU `srun` step it runs a single worker; give the step more CPUs (`srun --overlap -c N`) first. @@ -139,10 +102,6 @@ Run the suite in parallel with `pytest -n ` (pytest-xdist, in the `test` ### Code Style -- Docstrings use **numpy style** (`convention = "numpy"`). -- Lint rules: `D, E, F, I, NPY, PD, W`. -- `D` rules are ignored in `**/tests/**` and notebooks. -- Format: double quotes, spaces, 120 char line length. - Use a subagent to run tests and complex bash commands, especially those expected to return complex output. - Run independent tasks (multi-file edits across separate concerns, cross-cutting verifications, distinct review angles) in parallel via concurrent subagents in a single message. Subagent startup overhead is negligible relative to sequential blocking. Only sequence subagents when a later task needs an earlier task's output. @@ -189,17 +148,7 @@ Ask yourself if your test is actually covering the true function. ### Coding Philosophy -#### 1. Think Before Coding - -Don't assume. Don't hide confusion. Surface tradeoffs. - -Before implementing: -- State your assumptions explicitly. If uncertain, ask. -- If multiple interpretations exist, present them — don't pick silently. -- If a simpler approach exists, say so. Push back when warranted. -- If something is unclear, stop. Name what's confusing. Ask. - -#### 2. Simplicity First +#### 1. Simplicity First Minimum code that solves the problem. Nothing speculative. @@ -210,7 +159,7 @@ Minimum code that solves the problem. Nothing speculative. - If you write 200 lines and it could be 50, rewrite it. - Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify. -#### 3. Surgical Changes +#### 2. Surgical Changes Touch only what you must. Clean up only your own mess. @@ -225,18 +174,3 @@ When your changes create orphans: - Don't remove pre-existing dead code unless asked. The test: every changed line should trace directly to the user's request. - -#### 4. Goal-Driven Execution - -Define success criteria. Loop until verified. - -Transform tasks into verifiable goals: -- "Add validation" → "Write tests for invalid inputs, then make them pass" -- "Fix the bug" → "Write a test that reproduces it, then make it pass" -- "Refactor X" → "Ensure tests pass before and after" - -For multi-step tasks, state a brief plan: -1. [Step] → verify: [check] -2. [Step] → verify: [check] - -Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification. From 69391a1a8ac83cf351dac557eebd46a3371aead4 Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:50:41 -0700 Subject: [PATCH 22/72] ci: run the viscy-utils tests in their own job viscy-utils had no CI job on main or on dynacell-models: four of its test files ran inside the dynacell job and the rest (losses, metrics, meta_utils, optimizer health, CLI, lazy imports) ran nowhere. Mirror the viscy-data job on ubuntu-latest for Python 3.12 and 3.13, and make the gate job wait for it. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/test.yml | 29 ++++++++++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 616044d9a..8e4dbb2ad 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -91,6 +91,33 @@ jobs: run: uv run --frozen pytest --cov=viscy_data --cov-report=term-missing working-directory: packages/viscy-data + test-utils: + name: Test Utils (Python ${{ matrix.python-version }}, ubuntu-latest) + runs-on: ubuntu-latest + strategy: + fail-fast: true + matrix: + python-version: ["3.12", "3.13"] + + steps: + - name: Checkout repository + uses: actions/checkout@v5 + + - name: Set up uv with Python ${{ matrix.python-version }} + uses: astral-sh/setup-uv@v7 + with: + python-version: ${{ matrix.python-version }} + enable-cache: true + cache-suffix: ubuntu-latest-${{ matrix.python-version }} + + - name: Install dependencies + run: uv sync --frozen --all-extras --dev + working-directory: packages/viscy-utils + + - name: Run tests with coverage + run: uv run --frozen pytest --cov=viscy_utils --cov-report=term-missing + working-directory: packages/viscy-utils + test-applications: name: Test (${{ matrix.application }}, Python 3.13, ubuntu-latest) runs-on: ubuntu-latest @@ -166,7 +193,7 @@ jobs: check: name: All tests pass if: always() - needs: [test, test-data, test-data-extras, test-applications, test-dynacell-configs] + needs: [test, test-data, test-data-extras, test-utils, test-applications, test-dynacell-configs] runs-on: ubuntu-latest steps: - name: Verify all test jobs succeeded From cf8c7edbb03905d25e89b62d9f6c47f1f95e7ef0 Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:50:42 -0700 Subject: [PATCH 23/72] ci(dynacell): run the launcher, engine and prediction-writer suites Port the test-dynacell-configs job from dynacell-models, minus the eight test files that only arrive with the dynacell PR: sync viscy-utils' test group with dynacell, and add test_submit_benchmark_batch, test_engine, test_pipeline_cache, feature_metrics_test and the viscy-utils prediction-writer, prediction-metadata, monitor-health and LR-cooldown tests. The dynacell-models PR target is not carried over. Source on dynacell-models: 33d2fee5, 74fa18a4 (#497), 2d1ed32c (#506), 4450efdc (#518), 2798dee8 (#519), 2f9ef319 (#528). Co-Authored-By: Claude Opus 5.5 --- .github/workflows/test.yml | 21 +++++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 8e4dbb2ad..d1d5dcbef 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -146,7 +146,7 @@ jobs: working-directory: applications/${{ matrix.application }} test-dynacell-configs: - name: Test dynacell benchmark configs (Python 3.13, ubuntu-latest) + name: Test dynacell configs and regressions (Python 3.13, ubuntu-latest) runs-on: ubuntu-latest steps: @@ -166,10 +166,11 @@ jobs: # (falls back to numpy/scikit-image without CUDA), so the eval extra # installs and runs on a GPU-less runner. eval_gpu (cupy/cucim) is NOT # installed — those are the only CUDA-only deps. - run: uv sync --frozen --extra eval --group test + # Include viscy-utils' test group for the prediction-writer fixtures. + run: uv sync --frozen --package dynacell --package viscy-utils --extra eval --group test working-directory: applications/dynacell - - name: Run benchmark-schema + submit-tool + eval-runtime tests + - name: Run benchmark configs and pipeline regressions # test_benchmark_config_composition + test_submit_benchmark_job cover # config composition + the launcher. test_runtime + the two # test_evaluation_pipeline_parallel* suites cover the runtime module, @@ -179,14 +180,26 @@ jobs: # segmenter + feature-extractor model loads — but pipeline import still # needs the eval stack). test_evaluation_grouped drives the # multi-condition driver against the same cache-only fixture. + # + # test_submit_benchmark_batch covers the OTHER two srun emitters (array + # + chained-serial), which drifted out of sync with the single-job + # template because only the latter was under test. run: | - uv run --frozen pytest \ + uv run --frozen --no-sync pytest \ tests/test_benchmark_config_composition.py \ tests/test_submit_benchmark_job.py \ + tests/test_submit_benchmark_batch.py \ tests/test_runtime.py \ tests/test_evaluation_pipeline_parallel.py \ tests/test_evaluation_pipeline_parallel_cpu.py \ tests/test_evaluation_grouped.py \ + tests/test_engine.py \ + tests/test_pipeline_cache.py \ + src/dynacell/evaluation/feature_metrics_test.py \ + ../../packages/viscy-utils/tests/test_prediction_writer.py \ + ../../packages/viscy-utils/tests/test_prediction_metadata.py \ + ../../packages/viscy-utils/src/viscy_utils/callbacks/monitor_health_test.py \ + ../../packages/viscy-utils/src/viscy_utils/callbacks/linear_lr_cooldown_test.py \ -v working-directory: applications/dynacell From fdcbfba66d8dbbf4f6239bb12dd1d7576ebee622 Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 15:50:58 -0700 Subject: [PATCH 24/72] build: re-lock against the ported packages and main's dynacell Start from dynacell-models' uv.lock and re-resolve with `uv lock` against this tree, whose applications/dynacell/pyproject.toml is still main's. Against dynacell-models' lock this drops the ten dynacell-only packages (dinov3, etils, ftfy, jsonpath-rw, mlcroissant, pandas-stubs, ply, rdflib, submitit, termcolor) and resolves cubic back to 0.7.0; the dynacell PR restores them. Against main's lock it adds pytest-xdist and moves boto3/botocore 1.43.0 -> 1.43.20, cellpose 4.1.1 -> 4.2.1.1, pyarrow 19.0.1 -> 24.0.0, s3transfer and tracksdata; torch and lightning are unchanged. `uv lock --check` exits 0 (main's own lock does not). Co-Authored-By: Claude Opus 5.5 --- uv.lock | 2509 +++++++++++++++++++++++++------------------------------ 1 file changed, 1144 insertions(+), 1365 deletions(-) diff --git a/uv.lock b/uv.lock index 9b52e7d2d..9356f4a71 100644 --- a/uv.lock +++ b/uv.lock @@ -1,18 +1,24 @@ version = 1 -revision = 3 -requires-python = ">=3.12, <3.14" +revision = 5 +requires-python = ">=3.12" resolution-markers = [ - "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version >= '3.14' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version >= '3.14' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version >= '3.14' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version >= '3.14' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version >= '3.14' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.14' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.13.*' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version == '3.13.*' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version == '3.13.*' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.13.*' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.13.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.13.*' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", "python_full_version < '3.13' and platform_machine != 's390x' and sys_platform == 'win32'", - "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'win32'", "python_full_version < '3.13' and platform_machine == 's390x' and sys_platform == 'win32'", - "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'emscripten'", "python_full_version < '3.13' and platform_machine != 's390x' and sys_platform == 'emscripten'", - "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'emscripten'", "python_full_version < '3.13' and platform_machine == 's390x' and sys_platform == 'emscripten'", - "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", "python_full_version < '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", - "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", "python_full_version < '3.13' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", ] @@ -22,7 +28,6 @@ members = [ "cytoland", "dynacell", "dynaclr", - "eet-tracking", "viscy", "viscy-data", "viscy-models", @@ -85,24 +90,6 @@ dependencies = [ { name = "tifffile" }, ] -[[package]] -name = "aiobotocore" -version = "3.7.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "aiohttp" }, - { name = "aioitertools" }, - { name = "botocore" }, - { name = "jmespath" }, - { name = "multidict" }, - { name = "python-dateutil" }, - { name = "wrapt" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/e7/75/42cce839c2ec263ff74b10b650fe36b066fbb124cbee6f247eac0983e1ab/aiobotocore-3.7.0.tar.gz", hash = "sha256:c64d871ed5491a6571948dd48eabd185b46c6c23b64e3afd0c059fc7593ada30", size = 127054, upload-time = "2026-05-09T10:02:52.332Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/90/5f/85535dfb3cfd6442d66d1df1694062c5d6df02f895329e7e120b2a3d2b8b/aiobotocore-3.7.0-py3-none-any.whl", hash = "sha256:680bde7c64679a821a9312641b759d9497f790ba8b2e88c6959e6273ee765b8e", size = 89539, upload-time = "2026-05-09T10:02:50.389Z" }, -] - [[package]] name = "aiohappyeyeballs" version = "2.6.2" @@ -169,15 +156,47 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/af/cc/c122eabd7a1b7e0c9bbdd6be60e4715905b858399145d9df872bb94f1427/aiohttp-3.14.0-cp313-cp313-win32.whl", hash = "sha256:23f094a1ef64823fd35854ddf5c7a80a078162f37f9d2f7c6142b51a6affa456", size = 448656, upload-time = "2026-06-01T19:39:11.171Z" }, { url = "https://files.pythonhosted.org/packages/41/a5/bab07d79848a00eedd8ed979ccb302aaea3ac6eb9fa16bd0ed87135869b4/aiohttp-3.14.0-cp313-cp313-win_amd64.whl", hash = "sha256:e03abdaa17d553f17e1d1d06bb266b3970106c78051d06795723e748d8e49d11", size = 475803, upload-time = "2026-06-01T19:39:13.439Z" }, { url = "https://files.pythonhosted.org/packages/d1/a0/f03ade8566c153666a3871afccbedf6d99911da006325e1fc6cf72a2de99/aiohttp-3.14.0-cp313-cp313-win_arm64.whl", hash = "sha256:acdb400538cf4769543548bb5d1eb23d39bed4f96554a6078cb728c7cb2c268b", size = 443889, upload-time = "2026-06-01T19:39:15.945Z" }, -] - -[[package]] -name = "aioitertools" -version = "0.13.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/fd/3c/53c4a17a05fb9ea2313ee1777ff53f5e001aefd5cc85aa2f4c2d982e1e38/aioitertools-0.13.0.tar.gz", hash = "sha256:620bd241acc0bbb9ec819f1ab215866871b4bbd1f73836a55f799200ee86950c", size = 19322, upload-time = "2025-11-06T22:17:07.609Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/10/a1/510b0a7fadc6f43a6ce50152e69dbd86415240835868bb0bd9b5b88b1e06/aioitertools-0.13.0-py3-none-any.whl", hash = "sha256:0be0292b856f08dfac90e31f4739432f4cb6d7520ab9eb73e143f4f2fa5259be", size = 24182, upload-time = "2025-11-06T22:17:06.502Z" }, + { url = "https://files.pythonhosted.org/packages/28/03/5f36ab196a88ba5e9648ae5643e6531e67a3a8c0e96f9c6510ff41540fec/aiohttp-3.14.0-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:363ef9e91014e7891679bfb2ac0a7c6ea93435dbbfd10ecf41b9f06fcf506c5f", size = 503330, upload-time = "2026-06-01T19:39:18.195Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ce/8b49ec2f30f68e02f314f4832186cd45e583360a5a386058be36855d23b6/aiohttp-3.14.0-cp314-cp314-android_24_x86_64.whl", hash = "sha256:884a4edbdad77be9d0ef36142c8b504351b170df0bf62b51e784fadabf311c42", size = 509822, upload-time = "2026-06-01T19:39:20.396Z" }, + { url = "https://files.pythonhosted.org/packages/1a/fe/6edbf5d39bf29322b6816365b17ed8ede4dace164a3aea1abcd30110eb78/aiohttp-3.14.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:70ea956f6cc4a37620966b56c2e205d88ca3e6d85ec063277e414b1035cddad3", size = 483329, upload-time = "2026-06-01T19:39:22.607Z" }, + { url = "https://files.pythonhosted.org/packages/1b/5a/fae531bdbc6456fb6241f46b7b81e4d8a0dd3fc09118a0055dc7141ac1ec/aiohttp-3.14.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:ea3b9806c89f61da22fddf1f12dd524fb368e5e28f1261fbdafe5c3cd8ce893b", size = 489502, upload-time = "2026-06-01T19:39:24.881Z" }, + { url = "https://files.pythonhosted.org/packages/36/f4/48a7b0414db7fed77a03d5dde34508c026afd83510ab6bca08c313855776/aiohttp-3.14.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:a071be341c2bd9b0188e62d173509f024e0a35b1c342c53c50f8daaeda8c3bd8", size = 497357, upload-time = "2026-06-01T19:39:27.197Z" }, + { url = "https://files.pythonhosted.org/packages/75/75/e85a13a370acc007fca5feb1fd1b88ac2d8426e6dadd625479b7cadd55a3/aiohttp-3.14.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:198cfe61bf253b19da1fb3e0fa122249dc4f14c12709493fed8054aa0411cc76", size = 750898, upload-time = "2026-06-01T19:39:29.563Z" }, + { url = "https://files.pythonhosted.org/packages/9e/e4/3d637f800c724eff0e2bed64df72557444482366fd0a35b0cec0e6968f6c/aiohttp-3.14.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:9dc203d6ce6b9106d54e2a93f41dfdfebfbca2d99962ba503bfd3e5921a6549e", size = 506986, upload-time = "2026-06-01T19:39:31.872Z" }, + { url = "https://files.pythonhosted.org/packages/1d/df/35161f3598bf7501d2b2a805b41ab4f45a2e34150c421bcb4ef8c0d281a7/aiohttp-3.14.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9e19d17ab02bf16832a2c8c0d55a486792c5b1645665652ee9531aebcc30cb72", size = 508033, upload-time = "2026-06-01T19:39:34.137Z" }, + { url = "https://files.pythonhosted.org/packages/e5/39/b36e5d3d31e850fb4691dd3e941684ac490a2559249f6fa634b6b0fdf020/aiohttp-3.14.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d925fba0c14d5b498a8028b0107beebdfd16c5d48d702ff54f879cb017aaaca3", size = 1746213, upload-time = "2026-06-01T19:39:36.654Z" }, + { url = "https://files.pythonhosted.org/packages/b1/28/24e1409e605a9aa5d84abe0e2acb365354b70ae56d40948101cabe3341ab/aiohttp-3.14.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d33e61021222ce7f9792bcac870d6f58d8adfceda33ab857b01264f4560f2c5f", size = 1705862, upload-time = "2026-06-01T19:39:38.968Z" }, + { url = "https://files.pythonhosted.org/packages/8c/d0/e5eb3ff1daeaf644c7e36a957517672494122628e067c38b263fa04eda77/aiohttp-3.14.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:44eca38755d0105bb32f47d085f5dd449846a449e1245fc105889e3279dcf8e3", size = 1798909, upload-time = "2026-06-01T19:39:41.334Z" }, + { url = "https://files.pythonhosted.org/packages/d3/ba/8943f906f0570342886ababb9a722a44e360f786a028c5e0b0e29e3f735b/aiohttp-3.14.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f13087e06f68fea4941c21a0c541c00553aa16e4f8fd7bbe2b198df761e964d6", size = 1868892, upload-time = "2026-06-01T19:39:43.807Z" }, + { url = "https://files.pythonhosted.org/packages/3a/05/27df32c844b2156e1675a8d8ec22d963e3c8ba469ed7ceb1863320c7b521/aiohttp-3.14.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ff82be7f1ef73634cb77890a770743239bc3d487b848669be1c599889336dc0a", size = 1751659, upload-time = "2026-06-01T19:39:46.398Z" }, + { url = "https://files.pythonhosted.org/packages/7f/62/da182e5910ab912b2e88aa919b61a16046a37a95714a5795b02eb57b2d18/aiohttp-3.14.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a150c0875ac8fd87f1c398650841308a30d65facf7416b12dbdb9cfdcbe5a48c", size = 1578775, upload-time = "2026-06-01T19:39:48.902Z" }, + { url = "https://files.pythonhosted.org/packages/66/e3/53c67097e8a5ce98625e91e3fa7f43c9c6940de680345d03b3509a72a078/aiohttp-3.14.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:edc01ea4e1ec5a1649a28866262bf24195889ff7b27bdd947029a6086741de9b", size = 1710090, upload-time = "2026-06-01T19:39:51.392Z" }, + { url = "https://files.pythonhosted.org/packages/dd/55/0e2732ca598c7a4dfe8a775662376d0ca2977cb1030e48386d4da5d9a456/aiohttp-3.14.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:540632bf882ff8fc88f2e1697be0761578e89e0d79fb4a8a6d65dc5da7e729d4", size = 1715016, upload-time = "2026-06-01T19:39:53.807Z" }, + { url = "https://files.pythonhosted.org/packages/5a/96/f0b73730798c9ca525afc30b39f1f81bbe24e245d9654c54d3b39d63212d/aiohttp-3.14.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:860a86bc2c80237f5dff52edcf427e10a8d8352271fd84845429a3e60199e02c", size = 1763810, upload-time = "2026-06-01T19:39:56.31Z" }, + { url = "https://files.pythonhosted.org/packages/71/cc/11acb6c4518f448323405a7312b6f255d0f974a34373ad1db7633c4aadc8/aiohttp-3.14.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:5cbd50e6a50d6b99283a826b18cbdebf65b0797689a7535cb0e9dd37be0f63c3", size = 1573064, upload-time = "2026-06-01T19:39:58.718Z" }, + { url = "https://files.pythonhosted.org/packages/de/2d/28c31dde0a7dc98c0ee7d0da2ddcec3f7688c4fc131e5989e278d0c03c0a/aiohttp-3.14.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:20144819e99db593e22bbd2f3f2691a5e149f879142d6b8670254708853ff4fb", size = 1775765, upload-time = "2026-06-01T19:40:01.195Z" }, + { url = "https://files.pythonhosted.org/packages/b8/69/155c4ef3aec96417d47024800472b33b16c5d8a665371dcd044c2afdf25d/aiohttp-3.14.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:26b6d79aa54cb4ed50cc7d41ed14e99e0f1fc8e7c2d42f2e05b37aea897b2b52", size = 1733716, upload-time = "2026-06-01T19:40:03.631Z" }, + { url = "https://files.pythonhosted.org/packages/5f/44/6126116fd8a316b712bb615660b855c78466bb67ba1bb1742427eafcf7ac/aiohttp-3.14.0-cp314-cp314-win32.whl", hash = "sha256:106ed074a856f3e21d186b8579e2c8afb6da598e267cdaab01059e13db2fc44d", size = 453684, upload-time = "2026-06-01T19:40:06.277Z" }, + { url = "https://files.pythonhosted.org/packages/a2/d7/eff4c58a88c5cac5e38b55f44fb8a6d3929c3cbd77356e383e094d3220bd/aiohttp-3.14.0-cp314-cp314-win_amd64.whl", hash = "sha256:4f770846edae8f00ecc57af825bce811f787f87a7dcf0e90d191790efe5b31f7", size = 481758, upload-time = "2026-06-01T19:40:08.653Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ed/17b5bd9fbcb46e688f02e572f517754a9a75831e7b54702f027761dc4fa5/aiohttp-3.14.0-cp314-cp314-win_arm64.whl", hash = "sha256:acf1581c4f21ed4b80a2dded504d87b055a071a84d5737ea966435f768275ac6", size = 450557, upload-time = "2026-06-01T19:40:11.03Z" }, + { url = "https://files.pythonhosted.org/packages/12/34/6180103ce9aabc8ebff3f7bb55a1228ffe60f61042823031d9692cb7b101/aiohttp-3.14.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:6aa1a40f9cbb3da9f80714c5966b8946c21e6a2530d809b9498b33161e3c8733", size = 787878, upload-time = "2026-06-01T19:40:13.401Z" }, + { url = "https://files.pythonhosted.org/packages/92/e9/08954a40e8b7baa3d8beadd2b074b186e9b1e9c8ddabc288678a6265de50/aiohttp-3.14.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b62af5a8cc96a194eaa01a9ed7b34a3ffa58d3d8daaa1a0d7a749353ad12d228", size = 524400, upload-time = "2026-06-01T19:40:15.972Z" }, + { url = "https://files.pythonhosted.org/packages/08/6a/b5965a634ac4d5ba99a463314cf4ab214ca073fcdc38a15e0294273701fc/aiohttp-3.14.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6eb63b1417efaf7d1002a6ad034a40d44376afcc16508a57f8e74b49ad26a095", size = 527904, upload-time = "2026-06-01T19:40:18.28Z" }, + { url = "https://files.pythonhosted.org/packages/06/b4/932bcdd850c354d9bcca30f360e475d7852e30413fbbd44b182782ed5432/aiohttp-3.14.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c20b9ad156a79eb97be5cf9e069eec01d2f0dc8472ffbd75299a8b2d4c2cbbde", size = 1912162, upload-time = "2026-06-01T19:40:20.825Z" }, + { url = "https://files.pythonhosted.org/packages/c6/85/ce79bab0310d2e3fd2d7bc7e44412abeff7c8338f8a21dd0f2f1714989e5/aiohttp-3.14.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:40ae7b0642c25632c7eabc4a04754012691864d2a1b93becf7cddb76027b838a", size = 1778813, upload-time = "2026-06-01T19:40:23.726Z" }, + { url = "https://files.pythonhosted.org/packages/05/54/ba62ac2d1bc87e010aad23751e383b8794e45d931df67677313a2da78823/aiohttp-3.14.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:95f5217e76a046b9f228a101717ef8d42b1eb3d9d196d15202db5bf41df88936", size = 1899969, upload-time = "2026-06-01T19:40:26.406Z" }, + { url = "https://files.pythonhosted.org/packages/dc/82/7cc7907725d83a19f31551334061e1ab8e108b1d7ac52632a2a844a4acb5/aiohttp-3.14.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1a4a9f17e85b80878c176695c1998c790e83731d8271881e5d356488652a1f9e", size = 1991771, upload-time = "2026-06-01T19:40:29.061Z" }, + { url = "https://files.pythonhosted.org/packages/d0/1c/a57de71a4508c93a830b77c28af3d08cd97f606dedfc6b94275347744508/aiohttp-3.14.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:145262119b07d7f95abc1839add35ba2bfc84551d4b4660ca11542c0b215455b", size = 1868606, upload-time = "2026-06-01T19:40:31.843Z" }, + { url = "https://files.pythonhosted.org/packages/9c/ae/3839726cd49150a53ed340cc24ce5ba09d4c2117020ef9d45542bec5eb2f/aiohttp-3.14.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:49a33ded29b0b2fa7a367a02cf0fb89af602bb87542a16177ec8ce1c9c51d12a", size = 1665437, upload-time = "2026-06-01T19:40:35.01Z" }, + { url = "https://files.pythonhosted.org/packages/35/1e/c237923232c7da7f0392ea25d89fc5e60c0e93f685f4ebca8e7bcdd5271c/aiohttp-3.14.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2cc736a9c9fc2bc4dd71fd404815741b6573df27c3f985948ec4076989ac57de", size = 1834090, upload-time = "2026-06-01T19:40:37.733Z" }, + { url = "https://files.pythonhosted.org/packages/98/02/a5a7a2524f92d3911761b405a7c067c751891942144adc13e2ad79611e39/aiohttp-3.14.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:b4141a3e5342ee3053a9cab54d25b64ed28289c1041e4c54b3d99839314d90ce", size = 1816907, upload-time = "2026-06-01T19:40:40.46Z" }, + { url = "https://files.pythonhosted.org/packages/fa/76/a8b9f0d09234d516af9f2d7dd715557f33b5da3b0b56ead41d1170e86e3c/aiohttp-3.14.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:e30871b2d58996cb81aac52d2b1d15ac05257131ef0f90f18c2115a380fbfe7c", size = 1840382, upload-time = "2026-06-01T19:40:43.48Z" }, + { url = "https://files.pythonhosted.org/packages/c9/8e/140e715a0a4bbc211979ea30ec8396ad2ed5bf90ab87d8058fc4668b1923/aiohttp-3.14.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:667b881d083ccae3900ea5a241e17e5007ca78844c53ed389bb63d48f729d9c7", size = 1659497, upload-time = "2026-06-01T19:40:46.265Z" }, + { url = "https://files.pythonhosted.org/packages/10/c7/7ba5de8af9650b9767b063c675427b8685f43fa7ce563673a7bc3af60f08/aiohttp-3.14.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:b584dfe615d151e9b8f0a8ecb3aee6147f2927ec5b95ba25fe621f5377510928", size = 1870829, upload-time = "2026-06-01T19:40:49.583Z" }, + { url = "https://files.pythonhosted.org/packages/cc/bc/2aaab2f85cadb26ea59c091fa2b8e370d625154b5c14b478f1b489d07551/aiohttp-3.14.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6199707cc40e0e9cd39c36fbc97bec416c704e1d0ddce03412bb3b3e6a90ccd0", size = 1832281, upload-time = "2026-06-01T19:40:52.303Z" }, + { url = "https://files.pythonhosted.org/packages/39/98/31b9ad9fbc01f0075ee7221002df5fd2d10b647f451ca5f30edc802d9dd6/aiohttp-3.14.0-cp314-cp314t-win32.whl", hash = "sha256:a8d93334d4961c9d566b1f046c81dee475b7c21eb730728d38237bfa70d1c8e6", size = 490597, upload-time = "2026-06-01T19:40:54.937Z" }, + { url = "https://files.pythonhosted.org/packages/59/1f/299b21441c8de42ff70fddc7cfe65e92f810abcf740739a09b56f7835364/aiohttp-3.14.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2d2ffe9b614f50f069068b3b52e73414e4107fc10b7efc939a76acff9251fdd2", size = 525789, upload-time = "2026-06-01T19:40:57.306Z" }, + { url = "https://files.pythonhosted.org/packages/70/11/7f83fcba9ee05d4c54d61b3f8104da0d43a59adac44dd28effc0c9a10422/aiohttp-3.14.0-cp314-cp314t-win_arm64.whl", hash = "sha256:7a3fc4358e65826c515350f199c210de747cf669998211b1ee6c2e46de364b24", size = 467399, upload-time = "2026-06-01T19:40:59.993Z" }, ] [[package]] @@ -224,15 +243,6 @@ requires-dist = [ ] provides-extras = ["dev"] -[[package]] -name = "alabaster" -version = "1.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a6/f8/d9c74d0daf3f742840fd818d69cfae176fa332022fd44e3469487d5a9420/alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e", size = 24210, upload-time = "2024-07-26T18:15:03.762Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929, upload-time = "2024-07-26T18:15:02.05Z" }, -] - [[package]] name = "anndata" version = "0.12.6" @@ -290,31 +300,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" }, ] -[[package]] -name = "app-model" -version = "0.4.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "in-n-out" }, - { name = "psygnal" }, - { name = "pydantic" }, - { name = "pydantic-compat" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/8d/23/a9537fd7021e8b6ea7db96b73e66fe61e809a3b23338de07d1176e69e4ee/app_model-0.4.0.tar.gz", hash = "sha256:ccf667999f6c659e921ca3490b6da176971e67cf2f41abc34e33caa8cfa18573", size = 120529, upload-time = "2025-06-20T17:41:08.943Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/8f/fa/d7f4ae02a3b115abdf561d05ba8d5cdf9e3b2b5724b45d91e6cf08c163c3/app_model-0.4.0-py3-none-any.whl", hash = "sha256:5b1d69ee023d955b0c7a525771fd2fc02ff9d82cd2f12a982949423c3a901210", size = 65710, upload-time = "2025-06-20T17:41:07.696Z" }, -] - -[[package]] -name = "appdirs" -version = "1.4.4" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d7/d8/05696357e0311f5b5c316d7b95f46c669dd9c15aaeecbb48c7d0aeb88c40/appdirs-1.4.4.tar.gz", hash = "sha256:7d5d0167b2b1ba821647616af46a749d1c653740dd0d2415100fe26e27afdf41", size = 13470, upload-time = "2020-05-11T07:59:51.037Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/3b/00/2344469e2084fb287c2e0b57b72910309874c3245463acd6cf5e3db69324/appdirs-1.4.4-py2.py3-none-any.whl", hash = "sha256:a841dacd6b99318a741b166adb07e19ee71a274450e68237b4650ca1055ab128", size = 9566, upload-time = "2020-05-11T07:59:49.499Z" }, -] - [[package]] name = "appnope" version = "0.1.4" @@ -345,6 +330,16 @@ dependencies = [ ] sdist = { url = "https://files.pythonhosted.org/packages/5c/2d/db8af0df73c1cf454f71b2bbe5e356b8c1f8041c979f505b3d3186e520a9/argon2_cffi_bindings-25.1.0.tar.gz", hash = "sha256:b957f3e6ea4d55d820e40ff76f450952807013d361a65d7f28acc0acbf29229d", size = 1783441, upload-time = "2025-07-30T10:02:05.147Z" } wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/3c0a35f46e52108d4707c44b95cfe2afcafc50800b5450c197454569b776/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:3d3f05610594151994ca9ccb3c771115bdb4daef161976a266f0dd8aa9996b8f", size = 54393, upload-time = "2025-07-30T10:01:40.97Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f4/98bbd6ee89febd4f212696f13c03ca302b8552e7dbf9c8efa11ea4a388c3/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8b8efee945193e667a396cbc7b4fb7d357297d6234d30a489905d96caabde56b", size = 29328, upload-time = "2025-07-30T10:01:41.916Z" }, + { url = "https://files.pythonhosted.org/packages/43/24/90a01c0ef12ac91a6be05969f29944643bc1e5e461155ae6559befa8f00b/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3c6702abc36bf3ccba3f802b799505def420a1b7039862014a65db3205967f5a", size = 31269, upload-time = "2025-07-30T10:01:42.716Z" }, + { url = "https://files.pythonhosted.org/packages/d4/d3/942aa10782b2697eee7af5e12eeff5ebb325ccfb86dd8abda54174e377e4/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1c70058c6ab1e352304ac7e3b52554daadacd8d453c1752e547c76e9c99ac44", size = 86558, upload-time = "2025-07-30T10:01:43.943Z" }, + { url = "https://files.pythonhosted.org/packages/0d/82/b484f702fec5536e71836fc2dbc8c5267b3f6e78d2d539b4eaa6f0db8bf8/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2fd3bfbff3c5d74fef31a722f729bf93500910db650c925c2d6ef879a7e51cb", size = 92364, upload-time = "2025-07-30T10:01:44.887Z" }, + { url = "https://files.pythonhosted.org/packages/c9/c1/a606ff83b3f1735f3759ad0f2cd9e038a0ad11a3de3b6c673aa41c24bb7b/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4f9665de60b1b0e99bcd6be4f17d90339698ce954cfd8d9cf4f91c995165a92", size = 85637, upload-time = "2025-07-30T10:01:46.225Z" }, + { url = "https://files.pythonhosted.org/packages/44/b4/678503f12aceb0262f84fa201f6027ed77d71c5019ae03b399b97caa2f19/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ba92837e4a9aa6a508c8d2d7883ed5a8f6c308c89a4790e1e447a220deb79a85", size = 91934, upload-time = "2025-07-30T10:01:47.203Z" }, + { url = "https://files.pythonhosted.org/packages/f0/c7/f36bd08ef9bd9f0a9cff9428406651f5937ce27b6c5b07b92d41f91ae541/argon2_cffi_bindings-25.1.0-cp314-cp314t-win32.whl", hash = "sha256:84a461d4d84ae1295871329b346a97f68eade8c53b6ed9a7ca2d7467f3c8ff6f", size = 28158, upload-time = "2025-07-30T10:01:48.341Z" }, + { url = "https://files.pythonhosted.org/packages/b3/80/0106a7448abb24a2c467bf7d527fe5413b7fdfa4ad6d6a96a43a62ef3988/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b55aec3565b65f56455eebc9b9f34130440404f27fe21c3b375bf1ea4d8fbae6", size = 32597, upload-time = "2025-07-30T10:01:49.112Z" }, + { url = "https://files.pythonhosted.org/packages/05/b8/d663c9caea07e9180b2cb662772865230715cbd573ba3b5e81793d580316/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:87c33a52407e4c41f3b70a9c2d3f6056d88b10dad7695be708c5021673f55623", size = 28231, upload-time = "2025-07-30T10:01:49.92Z" }, { url = "https://files.pythonhosted.org/packages/1d/57/96b8b9f93166147826da5f90376e784a10582dd39a393c99bb62cfcf52f0/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:aecba1723ae35330a008418a91ea6cfcedf6d31e5fbaa056a166462ff066d500", size = 54121, upload-time = "2025-07-30T10:01:50.815Z" }, { url = "https://files.pythonhosted.org/packages/0a/08/a9bebdb2e0e602dde230bdde8021b29f71f7841bd54801bcfd514acb5dcf/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2630b6240b495dfab90aebe159ff784d08ea999aa4b0d17efa734055a07d2f44", size = 29177, upload-time = "2025-07-30T10:01:51.681Z" }, { url = "https://files.pythonhosted.org/packages/b6/02/d297943bcacf05e4f2a94ab6f462831dc20158614e5d067c35d4e63b9acb/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:7aef0c91e2c0fbca6fc68e7555aa60ef7008a739cbe045541e438373bc54d2b0", size = 31090, upload-time = "2025-07-30T10:01:53.184Z" }, @@ -433,6 +428,11 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b2/aa/e8d7dc17054815fd4a33032a73824d51129c607db3cc720e34e11b684994/awscrt-0.33.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:b99351915b0830eb89e997409970a90d164991ab765f357c9719eba9e1e45406", size = 4195537, upload-time = "2026-05-22T19:42:35.824Z" }, { url = "https://files.pythonhosted.org/packages/5e/b0/58e6a1945223610b5866eecb5978bf86dcb28eef85a47813c9dbd646c1de/awscrt-0.33.0-cp313-cp313t-win32.whl", hash = "sha256:ebf12555563e14f8d6d89a23456cb7b907481905efc3a2c1ae74928863685ab5", size = 4138190, upload-time = "2026-05-22T19:42:37.34Z" }, { url = "https://files.pythonhosted.org/packages/c3/be/fc020b8488f0d0e0b48d3d331ef4a3fca175e08894556b8f8eb7db586ad9/awscrt-0.33.0-cp313-cp313t-win_amd64.whl", hash = "sha256:7ac4afb54890343335807e9e25277030a429f069112146418ade98c02a2a211f", size = 4296418, upload-time = "2026-05-22T19:42:38.762Z" }, + { url = "https://files.pythonhosted.org/packages/d7/f1/fcb5d4bb2c7f8bcb28de35046e4b57f5b95f493305c95e7720ab0103df90/awscrt-0.33.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:3911132882a6687712b27541b55f19554a0a2e61e184f95ea35eddce38201d37", size = 3430854, upload-time = "2026-05-22T19:42:40.241Z" }, + { url = "https://files.pythonhosted.org/packages/a7/26/2c866f0bb59a8cd72e4149369bd3aaefa1636390def7d2503125ee9ad076/awscrt-0.33.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3e5627e05708ed036d092d01480e99eba92c370b4823c0f88a2389f68735cfcd", size = 4037329, upload-time = "2026-05-22T19:42:42.603Z" }, + { url = "https://files.pythonhosted.org/packages/57/e3/f7667f059a0162e8b5fdd3967fc36f5efdea5410edfcb91dc9774ddd0d5e/awscrt-0.33.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:26de77d818810074c84de5e3819c14ecba208da51faa3c16350c8c760384520d", size = 4325550, upload-time = "2026-05-22T19:42:44.393Z" }, + { url = "https://files.pythonhosted.org/packages/59/1c/7361ff0706189c6e08ee86bf311d75a68aefea7cf3e13884f02a0515d743/awscrt-0.33.0-cp314-cp314t-win32.whl", hash = "sha256:f460bf5d16580baa88c44eb73a08d46d0125146743b7849a2d338f39a8951c08", size = 4219307, upload-time = "2026-05-22T19:42:45.972Z" }, + { url = "https://files.pythonhosted.org/packages/4a/2c/409e529c5ef528b09ddf0ef116d23448b417a301c25f4cfda4d2b0451eae/awscrt-0.33.0-cp314-cp314t-win_amd64.whl", hash = "sha256:8d4d506da517475c935cfa89a7626d8d1610616c593b1c32b2dd5a4286f7e07d", size = 4396689, upload-time = "2026-05-22T19:42:47.878Z" }, ] [[package]] @@ -508,77 +508,49 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/10/89/70d22710fe3eb5eaad18fd74277ca970f1622bdd67279643268c9f489cf8/blosc2-4.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5fe4e26efde57e5fafb17518aaa8825d6ce1da6cb1a87785594edf8cc0474154", size = 6353541, upload-time = "2026-06-02T18:03:36.692Z" }, { url = "https://files.pythonhosted.org/packages/71/c6/054e8499bb2f61fcdaaff258408d0deb859fc077e50fa9389983cd98bbaf/blosc2-4.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2edede1fed53a485cb6153a8bc325d05bbc388cec737419fe556a1edf7e3b5e0", size = 6647836, upload-time = "2026-06-02T18:03:38.588Z" }, { url = "https://files.pythonhosted.org/packages/2e/be/89a8805247e8de0fba12a4f6ac254bb156fd0576742afb87714e58fb7a7e/blosc2-4.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:51d7537d97a50f0f8336550f0a5ec66e93599c8951a4144453a7c5ba60aef15b", size = 4203672, upload-time = "2026-06-02T18:03:40.491Z" }, + { url = "https://files.pythonhosted.org/packages/0c/b3/ccc8fcedc661bd8697d7fb601c5d7f1170cf981662e2d8270239dc5c339a/blosc2-4.4.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:f4ec2fd1f82d0f75eaa91c263d999ceda713d779a1d2ddb918719490825e8d76", size = 5954517, upload-time = "2026-06-02T18:03:42.576Z" }, + { url = "https://files.pythonhosted.org/packages/0f/12/e809357c8f8c617bec5ac88d6a982e3e32ea7dd9067bc3a47ebeffdde844/blosc2-4.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:016db2f3926d7d39e262ead711fc0980f0061ab7899aa27a724f335521345a90", size = 5110449, upload-time = "2026-06-02T18:03:44.739Z" }, + { url = "https://files.pythonhosted.org/packages/f0/09/37eeb0aa926bbe0d112c6ec1a6d7ce20fa3cf8f431fd774e52c96fcdb1b5/blosc2-4.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:30d2da937c886a1efa7b93bb08a23cdbd067f10308a6a329094a8e10f4cc44c3", size = 6365820, upload-time = "2026-06-02T18:03:47.531Z" }, + { url = "https://files.pythonhosted.org/packages/d0/36/d5ca09221aca7ec497b63635cb6260cb0ff9b997bc6cc195e648407ea40e/blosc2-4.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f803cecd7f69062a64fa287367dbad6989ad201278a94bf2a5ddf56d6edab965", size = 6647422, upload-time = "2026-06-02T18:03:50.414Z" }, + { url = "https://files.pythonhosted.org/packages/ec/3b/91e10bfe3cdee2708d17508c4d8fdbc0f8e328ad53eec21b8d024e0403f2/blosc2-4.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:2e9e0febd93bb4d7ecff1c5a0465da9c6e3b81fb262d655234732bccaf3caad3", size = 4286622, upload-time = "2026-06-02T18:03:52.715Z" }, + { url = "https://files.pythonhosted.org/packages/6e/3e/cb9719a9730109fe2d6dbabf253277e0a0e56d0805c5d6c6c6b0cf8e5d10/blosc2-4.4.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:cd8dbf99e0f30f6315037720bb2731b964ba84961eab5911d90ee8e80af046f0", size = 5989949, upload-time = "2026-06-02T18:03:54.804Z" }, + { url = "https://files.pythonhosted.org/packages/7f/cb/695999125111bb17ca81d54ea06425982095fffab2fcc3cbeac5e01e5dae/blosc2-4.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:eb2ea1089d15b8f91201df028f7e9c428065acd4f7721f8878a6f25caaac228c", size = 5157341, upload-time = "2026-06-02T18:03:56.85Z" }, + { url = "https://files.pythonhosted.org/packages/95/32/935022910ccd525c93cbd47ff257cc38a3f415ef7d170ca61ee47e8a37e0/blosc2-4.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7bfb7ab86b13f8cefe7ea08740e08df66d8fd63cb180c81a3a1321d17073f00d", size = 6317857, upload-time = "2026-06-02T18:03:58.846Z" }, + { url = "https://files.pythonhosted.org/packages/8c/f3/2fcf50f0331fc80f4dcaa9199dba278609b3e7d0ae8decbcea4ce54de8b2/blosc2-4.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ae547c72b9cc4ecbd6278e0f68306a00664ba66c8b3176b45d2c8426c28bd09", size = 6612822, upload-time = "2026-06-02T18:04:01.206Z" }, + { url = "https://files.pythonhosted.org/packages/a7/ff/71e766357b50d11a232e233cfd16caf85cc550e6ccea0b45bb4425b22357/blosc2-4.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:5bbdf3bf5746e18e6ec1bc4f33e758e39a01c3df98b127ffc30f173455229362", size = 4346450, upload-time = "2026-06-02T18:04:03.344Z" }, ] [[package]] name = "boto3" -version = "1.43.0" +version = "1.43.20" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "botocore" }, { name = "jmespath" }, { name = "s3transfer" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b7/65/47670987f2f9e181397872c7ee6415b7b95156d711b7eab6c55f66e575bc/boto3-1.43.0.tar.gz", hash = "sha256:80d44a943ef90aba7958ab31d30c155c198acc8a9581b5846b3878b2c8951086", size = 113143, upload-time = "2026-04-29T22:07:49.084Z" } +sdist = { url = "https://files.pythonhosted.org/packages/4b/7a/a3605b814fedd052fec798932f8d2b0459e61fd60ab2f652de1ce95815df/boto3-1.43.20.tar.gz", hash = "sha256:536d023d9f72dcec04254f71b216b78c6ee644be56ac61e780a6c73c1ddea445", size = 113210, upload-time = "2026-06-02T19:43:36.98Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b3/a0/3e6a0b1c1ea6bec76f71473727ef27abf3cd40e9709b3ebcbfbcfaae6f79/boto3-1.43.0-py3-none-any.whl", hash = "sha256:8ebe03754a4b73a5cb6ec2f14cca03ac33bd4760d0adea53da4724845130258b", size = 140497, upload-time = "2026-04-29T22:07:46.216Z" }, + { url = "https://files.pythonhosted.org/packages/5d/af/05411a9dc841d6e2344f2b8101338991bb32248e1bfa7cf8e2288327c025/boto3-1.43.20-py3-none-any.whl", hash = "sha256:ee878fa5cd739f38e68fbad535ff9bc3bf7c409290943a62f5e8bddad486aad4", size = 140536, upload-time = "2026-06-02T19:43:34.21Z" }, ] [[package]] name = "botocore" -version = "1.43.0" +version = "1.43.20" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "jmespath" }, { name = "python-dateutil" }, { name = "urllib3" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/28/79/2f4be1896db3db7ccf44504253a175d56b6bd6b669619edc5147d1aa21ea/botocore-1.43.0.tar.gz", hash = "sha256:e933b31a2d644253e1d029d7d39e99ba41b87e29300534f189744cc438cdf928", size = 15286817, upload-time = "2026-04-29T22:07:31.723Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/bf/4b/afc1fef8a43bafb139f57f73bbd70df82807af5934321e8112ae50668827/botocore-1.43.0-py3-none-any.whl", hash = "sha256:cc5b15eaec3c6eac05d8012cb5ef17ebe891beb88a16ca13c374bfaece1241e6", size = 14970102, upload-time = "2026-04-29T22:07:27Z" }, -] - -[[package]] -name = "build" -version = "1.5.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "colorama", marker = "os_name == 'nt'" }, - { name = "packaging" }, - { name = "pyproject-hooks" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/78/e0/df5e171f685f82f37b12e1f208064e24244911079d7b767447d1af7e0d70/build-1.5.0.tar.gz", hash = "sha256:302c22c3ba2a0fd5f3911918651341ebb3896176cbdec15bd421f80b1afc7647", size = 89796, upload-time = "2026-04-30T03:18:25.17Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0d/fe/6bea5c9162869c5beba5d9c8abbed835ec85bf1ec1fba05a3822325c45f3/build-1.5.0-py3-none-any.whl", hash = "sha256:13f3eecb844759ab66efec90ca17639bbf14dc06cb2fdf37a9010322d9c50a6f", size = 26018, upload-time = "2026-04-30T03:18:23.644Z" }, -] - -[[package]] -name = "cachey" -version = "0.2.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "heapdict" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/c6/9c/e3c959c1601013bf8a72e8bf91ea1ebc6fe8a2305bd2324b039ee0403277/cachey-0.2.1.tar.gz", hash = "sha256:0310ba8afe52729fa7626325c8d8356a8421c434bf887ac851e58dcf7cf056a6", size = 6461, upload-time = "2020-03-11T15:34:08.721Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/57/f0/e24f3e5d5d539abeb783087b87c26cfb99c259f1126700569e000243745a/cachey-0.2.1-py3-none-any.whl", hash = "sha256:49cf8528496ce3f99d47f1bd136b7c88237e55347a15d880f47cefc0615a83c3", size = 6415, upload-time = "2020-03-11T15:34:07.347Z" }, -] - -[[package]] -name = "cbcbox" -version = "2.929" -source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5b/04/ab59a00e6f003a5bee49464a14fa801b1498ecf1fb1ec32d5d847ab0e639/botocore-1.43.20.tar.gz", hash = "sha256:84fec90a8f25d11bb98176a3fa31c8b8e031b5be37d56f9a1a16f825b483ad4b", size = 15453850, upload-time = "2026-06-02T19:43:25.572Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/6a/9e/c41844f3a746500b88982817233f3f2f4fa6d3a554cedb9222bac9efcbea/cbcbox-2.929-py3-none-macosx_15_0_arm64.whl", hash = "sha256:610fd250f737b19f599d56cca299682a4519472b3ff6a13044502eb71e03931e", size = 59626733, upload-time = "2026-03-23T15:28:20.758Z" }, - { url = "https://files.pythonhosted.org/packages/3f/08/172af0d618ede8668862ae9c83ffcd929bc966610c1ce357b268edb33645/cbcbox-2.929-py3-none-macosx_15_0_x86_64.whl", hash = "sha256:b369071081176fd55ba9d104c2f2330133c36f0264ebe0215c50a366f290a050", size = 87883726, upload-time = "2026-03-23T15:28:24.874Z" }, - { url = "https://files.pythonhosted.org/packages/d4/c7/a57493dd959a57dcb8dc31aeef468c0e95d066d4bbf8fc59f9dda3a1fd97/cbcbox-2.929-py3-none-manylinux2014_aarch64.whl", hash = "sha256:62841ab4ed4e1c368bcba8d62c66cd7dd03f3dfaf1ecf4a01c6385a122d1946e", size = 145740150, upload-time = "2026-03-23T15:28:29.617Z" }, - { url = "https://files.pythonhosted.org/packages/4c/86/502b81d060603e1016a8cb471064e4e65d8009c2feed60ea878b8513a728/cbcbox-2.929-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a57a403cc44fb2af0aa53cb790a7642390f1836a5ff6a7a0b31b30eb6597e3e0", size = 181208771, upload-time = "2026-03-23T15:28:35.544Z" }, - { url = "https://files.pythonhosted.org/packages/0c/85/2fef9c7c3054ebfb9b0e84fabbeac776a18514b025efa5abd768c889f560/cbcbox-2.929-py3-none-win_amd64.whl", hash = "sha256:0a91420befb965ec1763aab62d7908d3a89a51af845e2a4e05c09d99a67f1151", size = 135305901, upload-time = "2026-03-23T15:28:42.021Z" }, + { url = "https://files.pythonhosted.org/packages/94/97/0bf341f86389a02cd3c4e6e2c597d15c7bf6c033a2abf1352473fc2e8354/botocore-1.43.20-py3-none-any.whl", hash = "sha256:1ee28afba70210f726c24f4bed1bf238a33542937fa2cf1b8cf2107287b85e04", size = 15135023, upload-time = "2026-06-02T19:43:20.939Z" }, ] [[package]] name = "cellpose" -version = "4.1.1" +version = "4.2.1.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "fastremap" }, @@ -595,9 +567,9 @@ dependencies = [ { name = "torchvision" }, { name = "tqdm" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/cb/b0/3dde4f82033a4b8e35a48d7419aa9c4f3e7c1100055a135790a41c47f19b/cellpose-4.1.1.tar.gz", hash = "sha256:859c732c8edede78ec7ee6537c5cfb18ab54f3dc01846adc10edca0cec124094", size = 4252891, upload-time = "2026-03-31T16:40:23.181Z" } +sdist = { url = "https://files.pythonhosted.org/packages/0c/e4/3d4606883a5489b86fa6ab5f65b9d0a243810f64efb934033fe425089d5a/cellpose-4.2.1.1.tar.gz", hash = "sha256:229eedea3977184202b2c87b3bd41c609facd742c7203bb4ad3cebd7b6bc6839", size = 4441350, upload-time = "2026-06-14T14:25:15.082Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/47/33/c2fbe5d074e2bb95bacdada02ebfa05915d211b67ab590419be1449d2115/cellpose-4.1.1-py3-none-any.whl", hash = "sha256:52d33d3c890df5572bec029ec4211388611b313c58f7b7073f47622b9befc32a", size = 213394, upload-time = "2026-03-31T16:40:21.147Z" }, + { url = "https://files.pythonhosted.org/packages/cc/20/d9d1fa1abffc8dab4381116ea0d91e8f8e4315acc038b76679608c097649/cellpose-4.2.1.1-py3-none-any.whl", hash = "sha256:6c5c5159fd459115bee390ffb01d94d5e1006b97c211bf3c1a7b37d5395a1a13", size = 203334, upload-time = "2026-06-14T14:25:13.797Z" }, ] [[package]] @@ -642,6 +614,28 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" }, { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" }, { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" }, + { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" }, + { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" }, + { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" }, + { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" }, + { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" }, + { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" }, + { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" }, + { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" }, + { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" }, + { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" }, + { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" }, + { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" }, + { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" }, ] [[package]] @@ -682,6 +676,38 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/73/55/c469897448a06e49f8fa03f6caae97074fde823f432a98f979cc42b90e69/charset_normalizer-3.4.7-cp313-cp313-win32.whl", hash = "sha256:4042d5c8f957e15221d423ba781e85d553722fc4113f523f2feb7b188cc34c5e", size = 148085, upload-time = "2026-04-02T09:27:03.192Z" }, { url = "https://files.pythonhosted.org/packages/5d/78/1b74c5bbb3f99b77a1715c91b3e0b5bdb6fe302d95ace4f5b1bec37b0167/charset_normalizer-3.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:3946fa46a0cf3e4c8cb1cc52f56bb536310d34f25f01ca9b6c16afa767dab110", size = 158819, upload-time = "2026-04-02T09:27:04.454Z" }, { url = "https://files.pythonhosted.org/packages/68/86/46bd42279d323deb8687c4a5a811fd548cb7d1de10cf6535d099877a9a9f/charset_normalizer-3.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:80d04837f55fc81da168b98de4f4b797ef007fc8a79ab71c6ec9bc4dd662b15b", size = 147915, upload-time = "2026-04-02T09:27:05.971Z" }, + { url = "https://files.pythonhosted.org/packages/97/c8/c67cb8c70e19ef1960b97b22ed2a1567711de46c4ddf19799923adc836c2/charset_normalizer-3.4.7-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c36c333c39be2dbca264d7803333c896ab8fa7d4d6f0ab7edb7dfd7aea6e98c0", size = 309234, upload-time = "2026-04-02T09:27:07.194Z" }, + { url = "https://files.pythonhosted.org/packages/99/85/c091fdee33f20de70d6c8b522743b6f831a2f1cd3ff86de4c6a827c48a76/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c2aed2e5e41f24ea8ef1590b8e848a79b56f3a5564a65ceec43c9d692dc7d8a", size = 208042, upload-time = "2026-04-02T09:27:08.749Z" }, + { url = "https://files.pythonhosted.org/packages/87/1c/ab2ce611b984d2fd5d86a5a8a19c1ae26acac6bad967da4967562c75114d/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:54523e136b8948060c0fa0bc7b1b50c32c186f2fceee897a495406bb6e311d2b", size = 228706, upload-time = "2026-04-02T09:27:09.951Z" }, + { url = "https://files.pythonhosted.org/packages/a8/29/2b1d2cb00bf085f59d29eb773ce58ec2d325430f8c216804a0a5cd83cbca/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:715479b9a2802ecac752a3b0efa2b0b60285cf962ee38414211abdfccc233b41", size = 224727, upload-time = "2026-04-02T09:27:11.175Z" }, + { url = "https://files.pythonhosted.org/packages/47/5c/032c2d5a07fe4d4855fea851209cca2b6f03ebeb6d4e3afdb3358386a684/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bd6c2a1c7573c64738d716488d2cdd3c00e340e4835707d8fdb8dc1a66ef164e", size = 215882, upload-time = "2026-04-02T09:27:12.446Z" }, + { url = "https://files.pythonhosted.org/packages/2c/c2/356065d5a8b78ed04499cae5f339f091946a6a74f91e03476c33f0ab7100/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:c45e9440fb78f8ddabcf714b68f936737a121355bf59f3907f4e17721b9d1aae", size = 200860, upload-time = "2026-04-02T09:27:13.721Z" }, + { url = "https://files.pythonhosted.org/packages/0c/cd/a32a84217ced5039f53b29f460962abb2d4420def55afabe45b1c3c7483d/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3534e7dcbdcf757da6b85a0bbf5b6868786d5982dd959b065e65481644817a18", size = 211564, upload-time = "2026-04-02T09:27:15.272Z" }, + { url = "https://files.pythonhosted.org/packages/44/86/58e6f13ce26cc3b8f4a36b94a0f22ae2f00a72534520f4ae6857c4b81f89/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e8ac484bf18ce6975760921bb6148041faa8fef0547200386ea0b52b5d27bf7b", size = 211276, upload-time = "2026-04-02T09:27:16.834Z" }, + { url = "https://files.pythonhosted.org/packages/8f/fe/d17c32dc72e17e155e06883efa84514ca375f8a528ba2546bee73fc4df81/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a5fe03b42827c13cdccd08e6c0247b6a6d4b5e3cdc53fd1749f5896adcdc2356", size = 201238, upload-time = "2026-04-02T09:27:18.229Z" }, + { url = "https://files.pythonhosted.org/packages/6a/29/f33daa50b06525a237451cdb6c69da366c381a3dadcd833fa5676bc468b3/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:2d6eb928e13016cea4f1f21d1e10c1cebd5a421bc57ddf5b1142ae3f86824fab", size = 230189, upload-time = "2026-04-02T09:27:19.445Z" }, + { url = "https://files.pythonhosted.org/packages/b6/6e/52c84015394a6a0bdcd435210a7e944c5f94ea1055f5cc5d56c5fe368e7b/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e74327fb75de8986940def6e8dee4f127cc9752bee7355bb323cc5b2659b6d46", size = 211352, upload-time = "2026-04-02T09:27:20.79Z" }, + { url = "https://files.pythonhosted.org/packages/8c/d7/4353be581b373033fb9198bf1da3cf8f09c1082561e8e922aa7b39bf9fe8/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d6038d37043bced98a66e68d3aa2b6a35505dc01328cd65217cefe82f25def44", size = 227024, upload-time = "2026-04-02T09:27:22.063Z" }, + { url = "https://files.pythonhosted.org/packages/30/45/99d18aa925bd1740098ccd3060e238e21115fffbfdcb8f3ece837d0ace6c/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7579e913a5339fb8fa133f6bbcfd8e6749696206cf05acdbdca71a1b436d8e72", size = 217869, upload-time = "2026-04-02T09:27:23.486Z" }, + { url = "https://files.pythonhosted.org/packages/5c/05/5ee478aa53f4bb7996482153d4bfe1b89e0f087f0ab6b294fcf92d595873/charset_normalizer-3.4.7-cp314-cp314-win32.whl", hash = "sha256:5b77459df20e08151cd6f8b9ef8ef1f961ef73d85c21a555c7eed5b79410ec10", size = 148541, upload-time = "2026-04-02T09:27:25.146Z" }, + { url = "https://files.pythonhosted.org/packages/48/77/72dcb0921b2ce86420b2d79d454c7022bf5be40202a2a07906b9f2a35c97/charset_normalizer-3.4.7-cp314-cp314-win_amd64.whl", hash = "sha256:92a0a01ead5e668468e952e4238cccd7c537364eb7d851ab144ab6627dbbe12f", size = 159634, upload-time = "2026-04-02T09:27:26.642Z" }, + { url = "https://files.pythonhosted.org/packages/c6/a3/c2369911cd72f02386e4e340770f6e158c7980267da16af8f668217abaa0/charset_normalizer-3.4.7-cp314-cp314-win_arm64.whl", hash = "sha256:67f6279d125ca0046a7fd386d01b311c6363844deac3e5b069b514ba3e63c246", size = 148384, upload-time = "2026-04-02T09:27:28.271Z" }, + { url = "https://files.pythonhosted.org/packages/94/09/7e8a7f73d24dba1f0035fbbf014d2c36828fc1bf9c88f84093e57d315935/charset_normalizer-3.4.7-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:effc3f449787117233702311a1b7d8f59cba9ced946ba727bdc329ec69028e24", size = 330133, upload-time = "2026-04-02T09:27:29.474Z" }, + { url = "https://files.pythonhosted.org/packages/8d/da/96975ddb11f8e977f706f45cddd8540fd8242f71ecdb5d18a80723dcf62c/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fbccdc05410c9ee21bbf16a35f4c1d16123dcdeb8a1d38f33654fa21d0234f79", size = 216257, upload-time = "2026-04-02T09:27:30.793Z" }, + { url = "https://files.pythonhosted.org/packages/e5/e8/1d63bf8ef2d388e95c64b2098f45f84758f6d102a087552da1485912637b/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:733784b6d6def852c814bce5f318d25da2ee65dd4839a0718641c696e09a2960", size = 234851, upload-time = "2026-04-02T09:27:32.44Z" }, + { url = "https://files.pythonhosted.org/packages/9b/40/e5ff04233e70da2681fa43969ad6f66ca5611d7e669be0246c4c7aaf6dc8/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a89c23ef8d2c6b27fd200a42aa4ac72786e7c60d40efdc76e6011260b6e949c4", size = 233393, upload-time = "2026-04-02T09:27:34.03Z" }, + { url = "https://files.pythonhosted.org/packages/be/c1/06c6c49d5a5450f76899992f1ee40b41d076aee9279b49cf9974d2f313d5/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c114670c45346afedc0d947faf3c7f701051d2518b943679c8ff88befe14f8e", size = 223251, upload-time = "2026-04-02T09:27:35.369Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9f/f2ff16fb050946169e3e1f82134d107e5d4ae72647ec8a1b1446c148480f/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:a180c5e59792af262bf263b21a3c49353f25945d8d9f70628e73de370d55e1e1", size = 206609, upload-time = "2026-04-02T09:27:36.661Z" }, + { url = "https://files.pythonhosted.org/packages/69/d5/a527c0cd8d64d2eab7459784fb4169a0ac76e5a6fc5237337982fd61347e/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3c9a494bc5ec77d43cea229c4f6db1e4d8fe7e1bbffa8b6f0f0032430ff8ab44", size = 220014, upload-time = "2026-04-02T09:27:38.019Z" }, + { url = "https://files.pythonhosted.org/packages/7e/80/8a7b8104a3e203074dc9aa2c613d4b726c0e136bad1cc734594b02867972/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8d828b6667a32a728a1ad1d93957cdf37489c57b97ae6c4de2860fa749b8fc1e", size = 218979, upload-time = "2026-04-02T09:27:39.37Z" }, + { url = "https://files.pythonhosted.org/packages/02/9a/b759b503d507f375b2b5c153e4d2ee0a75aa215b7f2489cf314f4541f2c0/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cf1493cd8607bec4d8a7b9b004e699fcf8f9103a9284cc94962cb73d20f9d4a3", size = 209238, upload-time = "2026-04-02T09:27:40.722Z" }, + { url = "https://files.pythonhosted.org/packages/c2/4e/0f3f5d47b86bdb79256e7290b26ac847a2832d9a4033f7eb2cd4bcf4bb5b/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0c96c3b819b5c3e9e165495db84d41914d6894d55181d2d108cc1a69bfc9cce0", size = 236110, upload-time = "2026-04-02T09:27:42.33Z" }, + { url = "https://files.pythonhosted.org/packages/96/23/bce28734eb3ed2c91dcf93abeb8a5cf393a7b2749725030bb630e554fdd8/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:752a45dc4a6934060b3b0dab47e04edc3326575f82be64bc4fc293914566503e", size = 219824, upload-time = "2026-04-02T09:27:43.924Z" }, + { url = "https://files.pythonhosted.org/packages/2c/6f/6e897c6984cc4d41af319b077f2f600fc8214eb2fe2d6bcb79141b882400/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:8778f0c7a52e56f75d12dae53ae320fae900a8b9b4164b981b9c5ce059cd1fcb", size = 233103, upload-time = "2026-04-02T09:27:45.348Z" }, + { url = "https://files.pythonhosted.org/packages/76/22/ef7bd0fe480a0ae9b656189ec00744b60933f68b4f42a7bb06589f6f576a/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ce3412fbe1e31eb81ea42f4169ed94861c56e643189e1e75f0041f3fe7020abe", size = 225194, upload-time = "2026-04-02T09:27:46.706Z" }, + { url = "https://files.pythonhosted.org/packages/c5/a7/0e0ab3e0b5bc1219bd80a6a0d4d72ca74d9250cb2382b7c699c147e06017/charset_normalizer-3.4.7-cp314-cp314t-win32.whl", hash = "sha256:c03a41a8784091e67a39648f70c5f97b5b6a37f216896d44d2cdcb82615339a0", size = 159827, upload-time = "2026-04-02T09:27:48.053Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1d/29d32e0fb40864b1f878c7f5a0b343ae676c6e2b271a2d55cc3a152391da/charset_normalizer-3.4.7-cp314-cp314t-win_amd64.whl", hash = "sha256:03853ed82eeebbce3c2abfdbc98c96dc205f32a79627688ac9a27370ea61a49c", size = 174168, upload-time = "2026-04-02T09:27:49.795Z" }, + { url = "https://files.pythonhosted.org/packages/de/32/d92444ad05c7a6e41fb2036749777c163baf7a0301a040cb672d6b2b1ae9/charset_normalizer-3.4.7-cp314-cp314t-win_arm64.whl", hash = "sha256:c35abb8bfff0185efac5878da64c45dafd2b37fb0383add1be155a763c1f083d", size = 153018, upload-time = "2026-04-02T09:27:51.116Z" }, { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", hash = "sha256:3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d", size = 61958, upload-time = "2026-04-02T09:28:37.794Z" }, ] @@ -790,6 +816,28 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" }, { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" }, { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" }, + { url = "https://files.pythonhosted.org/packages/72/8b/4546f3ab60f78c514ffb7d01a0bd743f90de36f0019d1be84d0a708a580a/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a", size = 292189, upload-time = "2025-07-26T12:02:16.095Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e1/3542a9cb596cadd76fcef413f19c79216e002623158befe6daa03dbfa88c/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77", size = 273251, upload-time = "2025-07-26T12:02:17.524Z" }, + { url = "https://files.pythonhosted.org/packages/b1/71/f93e1e9471d189f79d0ce2497007731c1e6bf9ef6d1d61b911430c3db4e5/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5", size = 335810, upload-time = "2025-07-26T12:02:18.9Z" }, + { url = "https://files.pythonhosted.org/packages/91/f9/e35f4c1c93f9275d4e38681a80506b5510e9327350c51f8d4a5a724d178c/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4", size = 382871, upload-time = "2025-07-26T12:02:20.418Z" }, + { url = "https://files.pythonhosted.org/packages/b5/71/47b512f936f66a0a900d81c396a7e60d73419868fba959c61efed7a8ab46/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36", size = 386264, upload-time = "2025-07-26T12:02:21.916Z" }, + { url = "https://files.pythonhosted.org/packages/04/5f/9ff93450ba96b09c7c2b3f81c94de31c89f92292f1380261bd7195bea4ea/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3", size = 363819, upload-time = "2025-07-26T12:02:23.759Z" }, + { url = "https://files.pythonhosted.org/packages/3e/a6/0b185d4cc480ee494945cde102cb0149ae830b5fa17bf855b95f2e70ad13/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b", size = 1333650, upload-time = "2025-07-26T12:02:26.181Z" }, + { url = "https://files.pythonhosted.org/packages/43/d7/afdc95580ca56f30fbcd3060250f66cedbde69b4547028863abd8aa3b47e/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36", size = 1404833, upload-time = "2025-07-26T12:02:28.782Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e2/366af18a6d386f41132a48f033cbd2102e9b0cf6345d35ff0826cd984566/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d", size = 189692, upload-time = "2025-07-26T12:02:30.128Z" }, + { url = "https://files.pythonhosted.org/packages/7d/c2/57f54b03d0f22d4044b8afb9ca0e184f8b1afd57b4f735c2fa70883dc601/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd", size = 232424, upload-time = "2025-07-26T12:02:31.395Z" }, + { url = "https://files.pythonhosted.org/packages/18/79/a9416650df9b525737ab521aa181ccc42d56016d2123ddcb7b58e926a42c/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339", size = 198300, upload-time = "2025-07-26T12:02:32.956Z" }, + { url = "https://files.pythonhosted.org/packages/1f/42/38c159a7d0f2b7b9c04c64ab317042bb6952b713ba875c1681529a2932fe/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772", size = 306769, upload-time = "2025-07-26T12:02:34.2Z" }, + { url = "https://files.pythonhosted.org/packages/c3/6c/26a8205f24bca10974e77460de68d3d7c63e282e23782f1239f226fcae6f/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77", size = 287892, upload-time = "2025-07-26T12:02:35.807Z" }, + { url = "https://files.pythonhosted.org/packages/66/06/8a475c8ab718ebfd7925661747dbb3c3ee9c82ac834ccb3570be49d129f4/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13", size = 326748, upload-time = "2025-07-26T12:02:37.193Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a3/c5ca9f010a44c223f098fccd8b158bb1cb287378a31ac141f04730dc49be/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe", size = 375554, upload-time = "2025-07-26T12:02:38.894Z" }, + { url = "https://files.pythonhosted.org/packages/80/5b/68bd33ae63fac658a4145088c1e894405e07584a316738710b636c6d0333/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f", size = 388118, upload-time = "2025-07-26T12:02:40.642Z" }, + { url = "https://files.pythonhosted.org/packages/40/52/4c285a6435940ae25d7410a6c36bda5145839bc3f0beb20c707cda18b9d2/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0", size = 352555, upload-time = "2025-07-26T12:02:42.25Z" }, + { url = "https://files.pythonhosted.org/packages/24/ee/3e81e1dd174f5c7fefe50e85d0892de05ca4e26ef1c9a59c2a57e43b865a/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4", size = 1322295, upload-time = "2025-07-26T12:02:44.668Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b2/6d913d4d04e14379de429057cd169e5e00f6c2af3bb13e1710bcbdb5da12/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f", size = 1391027, upload-time = "2025-07-26T12:02:47.09Z" }, + { url = "https://files.pythonhosted.org/packages/93/8a/68a4ec5c55a2971213d29a9374913f7e9f18581945a7a31d1a39b5d2dfe5/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae", size = 202428, upload-time = "2025-07-26T12:02:48.691Z" }, + { url = "https://files.pythonhosted.org/packages/fa/96/fd9f641ffedc4fa3ace923af73b9d07e869496c9cc7a459103e6e978992f/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc", size = 250331, upload-time = "2025-07-26T12:02:50.137Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831, upload-time = "2025-07-26T12:02:51.449Z" }, ] [[package]] @@ -858,25 +906,39 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/cf/c2/cd91ead503045161092d3845f7bb95ea2f25131ce96d3e314dd835d91b9c/coverage-7.14.1-cp313-cp313t-win32.whl", hash = "sha256:3758dd0a7f1fa57365ef2e781df0f0731d38b6e3772259d13dae4bd8a958d4b1", size = 223259, upload-time = "2026-05-26T20:40:20.381Z" }, { url = "https://files.pythonhosted.org/packages/71/9f/1e28d97e6bd2c76b07f38b7c02870f1371255ff6717f54eca578fcbbdd0e/coverage-7.14.1-cp313-cp313t-win_amd64.whl", hash = "sha256:6ff665fb023a77386fe11685190cee1f60a7d635994a30d9b0a061533d470fce", size = 224320, upload-time = "2026-05-26T20:40:22.316Z" }, { url = "https://files.pythonhosted.org/packages/a9/e0/d936e908f0e1efa55e52b91e01b52f1055cef5e1ab2718493390ed8e2fb8/coverage-7.14.1-cp313-cp313t-win_arm64.whl", hash = "sha256:17a5a241e5997621a956a7f402a7433ef4221e5152809b785bec79e2323799f1", size = 222577, upload-time = "2026-05-26T20:40:24.894Z" }, + { url = "https://files.pythonhosted.org/packages/d6/34/fc2f101b151af3799a101f0550b0454aa008afdc0add677394ec4aa8ea10/coverage-7.14.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d5ed429d0b8edaac649e889b4ffcedb6c80b06629a3f93050e3dddfb99235bee", size = 220091, upload-time = "2026-05-26T20:40:27.249Z" }, + { url = "https://files.pythonhosted.org/packages/3d/a7/1ebae2ab5b961b5c79bb09fe7b3ac99edb190d8be4a8c510b2cf66f46468/coverage-7.14.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:8011224a62280e50dab346960c03cf47aca1a1e09e608c0fb33fd6e0cc8e9500", size = 220421, upload-time = "2026-05-26T20:40:30.084Z" }, + { url = "https://files.pythonhosted.org/packages/5e/90/92aca9cf0acc95123c96cd1eb1f08917897a7f5dee01e15738922971ec31/coverage-7.14.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:12c42ec1e14f553c4f817e989365982e646e27211f10a0f717855b94a79c8906", size = 251466, upload-time = "2026-05-26T20:40:32.542Z" }, + { url = "https://files.pythonhosted.org/packages/26/2b/78048cbe3b999f6cbf9cc0d90abba6a88a3e0863a8c1c6cbc762f3f8802f/coverage-7.14.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:06144cd511cf2624873a035c5069cf297144f6e77a73ee3d7a55b605ec5efb42", size = 253973, upload-time = "2026-05-26T20:40:34.473Z" }, + { url = "https://files.pythonhosted.org/packages/8e/21/c2e33b29d1cfde484a19d437afc343c6cd30b08d78cbbf9f5aff14e57b2b/coverage-7.14.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a311d8e1da24be5c1ccf85cbfb06315dbaa1703d5a1eab3f6432c72b837917c8", size = 255318, upload-time = "2026-05-26T20:40:38.154Z" }, + { url = "https://files.pythonhosted.org/packages/8e/ee/aad2f108d63b769121005302f16bf66db8625c88ceaba466942e09a2607e/coverage-7.14.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c79cead5b5bc584d9c71451cb984d0e3a84e0c0937379c8efcbf27c8d661b851", size = 257633, upload-time = "2026-05-26T20:40:40.164Z" }, + { url = "https://files.pythonhosted.org/packages/c2/f8/11a2c29b4fd76d9849f81d0bb812ec0017a9396df3217214e38934a8c837/coverage-7.14.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dcbf65f1f66a26cdd88c35cf68fb4729c5d1cd2e88added72420541dfb212034", size = 251488, upload-time = "2026-05-26T20:40:42.631Z" }, + { url = "https://files.pythonhosted.org/packages/c9/b8/9a5820de4b8ac2b71d85e3b5fb49108d7469c665f0e2ad0dd7569023e305/coverage-7.14.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fd86572566fb40189a8260446158235159bc7a82dfbc87a3b39cf4fb57fcec1c", size = 253329, upload-time = "2026-05-26T20:40:45.208Z" }, + { url = "https://files.pythonhosted.org/packages/6b/ff/f33e4823667e27548e8fd8df44217515303f9808d0ff29817db56f87d990/coverage-7.14.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:7771b601718fdde84832c3a434ca9bbf4ae9adbc49d84198b4110700c3c77c36", size = 251291, upload-time = "2026-05-26T20:40:47.502Z" }, + { url = "https://files.pythonhosted.org/packages/68/9b/489db0ebb209054766b90a9014a45f6d26eb724c02ec21311c3733b5a644/coverage-7.14.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:39b21e212c55af06fa375e3dbf90a8a8e38792f3a910c580066d23563830ddd5", size = 255564, upload-time = "2026-05-26T20:40:49.372Z" }, + { url = "https://files.pythonhosted.org/packages/27/b5/16bc2d4c2409b23c7737edb68c83bc89e345f378050549fe1d75ac7d34d5/coverage-7.14.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:f2302660e32562a532b442480121aef8aa61a5bdb20b30bf0adab29f10a5a4b4", size = 251107, upload-time = "2026-05-26T20:40:51.677Z" }, + { url = "https://files.pythonhosted.org/packages/7d/0c/2629997469a00cd069d588a41c9dc887610f2775ae89d250c4791e65272a/coverage-7.14.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:03a6f93c1ec3b7f2e77b5dbcc5573a2c21f12529a5c6bbe0f16f72303cc2fa4d", size = 252764, upload-time = "2026-05-26T20:40:54.267Z" }, + { url = "https://files.pythonhosted.org/packages/d2/ee/f78d63c8f079e0d7211c7e2401fa17e311514534ba61bae03e4b287ce4ab/coverage-7.14.1-cp314-cp314-win32.whl", hash = "sha256:8a3ce026d73290f42f08dafecbd82c193a74df280461fbf97300fec51fd133ee", size = 222837, upload-time = "2026-05-26T20:40:56.496Z" }, + { url = "https://files.pythonhosted.org/packages/dc/b9/be539854f93a70dfbeec69117f33ec70dc42ff0b65b5b07ab8d40d04228e/coverage-7.14.1-cp314-cp314-win_amd64.whl", hash = "sha256:114c95ef29302423b87d159075805f4ab973254a2638a5d7d046c94887cc87d7", size = 223650, upload-time = "2026-05-26T20:40:58.351Z" }, + { url = "https://files.pythonhosted.org/packages/fe/9e/24e2842fef40f35ac82ba3a7719c8023d011bf3bf652d0675316a9d088a1/coverage-7.14.1-cp314-cp314-win_arm64.whl", hash = "sha256:a07891c3f4805442b31b71e84ba3cf29ed1aa9a428284e06deeb4b23e5b46343", size = 222218, upload-time = "2026-05-26T20:41:00.321Z" }, + { url = "https://files.pythonhosted.org/packages/0a/1d/ac0a9df5fe31c1e8bdd658074905fc12844a05c1a7e3fdb8417e97c31e23/coverage-7.14.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1101a5ebb083aecb625ebb6209d4105b58f647b093cb2dc8122d7b33f743cfe1", size = 220822, upload-time = "2026-05-26T20:41:02.281Z" }, + { url = "https://files.pythonhosted.org/packages/32/cf/f964fd9aff20323f9f1a726c97135f8a76bcd87b92dad141a456a43f3c64/coverage-7.14.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:851b9e1e4e8a4608e77c79714b2e77c0970d2ed7202a05e92ae407817481887b", size = 221084, upload-time = "2026-05-26T20:41:04.593Z" }, + { url = "https://files.pythonhosted.org/packages/d8/5e/7e5ef2aba844de2b80d678619fcf0841b42e3f37f16411226f3fe4c1016f/coverage-7.14.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d5b89cdfb2ee051b71e8c3c70bd81a9eff81100f736a269136fe1a68efe00474", size = 262454, upload-time = "2026-05-26T20:41:06.641Z" }, + { url = "https://files.pythonhosted.org/packages/64/62/75809bded87015cc4935524218a2a8ed8dd1a8498bfed30a2f4f7a4b4d34/coverage-7.14.1-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0177614a0370f227888b4e436a7c55686d6a9f90eb1ade2b624ba685a1686e86", size = 264578, upload-time = "2026-05-26T20:41:08.556Z" }, + { url = "https://files.pythonhosted.org/packages/f3/42/d33392dc14633525012d2d504fa1a33b05538bf535f5c1d64675e5754b78/coverage-7.14.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2d69af5dea2de76fc485a83032a630523f985198b7e25be901ec60181587b01e", size = 266981, upload-time = "2026-05-26T20:41:10.824Z" }, + { url = "https://files.pythonhosted.org/packages/2a/49/0157c4428c2aca7f1e09d5565930586fd5ae36f1655f08b0daa7cf1fcae1/coverage-7.14.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:35ab22d91de736e8966b980dc355cbcdd2c6dbbcfe275f9a2991bc8a91b3df65", size = 268112, upload-time = "2026-05-26T20:41:12.966Z" }, + { url = "https://files.pythonhosted.org/packages/96/26/86b9ce71f4092b1ed325ce1421698081df1286b833400b6836912834d6e0/coverage-7.14.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:357d4e32935c36588aaba057d734fa32428c360c9fc2e4442afbf1b646beee6e", size = 261558, upload-time = "2026-05-26T20:41:15Z" }, + { url = "https://files.pythonhosted.org/packages/20/4c/c311210c5472cf5401d8422b0d7812cdd520f24417673afabda6c323faca/coverage-7.14.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:51bd64741cc6fa065abd300ede1afe5a5291ece9c31da8b24884deda48bcc3f8", size = 264447, upload-time = "2026-05-26T20:41:17.369Z" }, + { url = "https://files.pythonhosted.org/packages/fb/71/59513f8710ed3e6b0ac0a050a5b7e977bb9c9e880354863b5d00d8809256/coverage-7.14.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:9132cd363a68a4c3daa7c8704a654b1e39d3360f6f5b8ddd470608a945236c07", size = 262048, upload-time = "2026-05-26T20:41:19.309Z" }, + { url = "https://files.pythonhosted.org/packages/84/8d/bceed32dc494f5bbf50f775cd2e78ca814953942b5ea28d3c1c3ac316f14/coverage-7.14.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:07c6290b1697b862c0478eab545eec949a0d0e4d6d03497f446d706da3b4f2de", size = 265781, upload-time = "2026-05-26T20:41:21.559Z" }, + { url = "https://files.pythonhosted.org/packages/e7/c5/9348fe40dbfd4991aaf78df2c6c3098bfb2cc834d1fd362a64b4efef855a/coverage-7.14.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:5ea0c297e27133853b4d8a3eb799bff5a2dbd9f2f41537a240d337ac9b4df890", size = 260896, upload-time = "2026-05-26T20:41:23.428Z" }, + { url = "https://files.pythonhosted.org/packages/ca/92/1ea0f03929da7cf87206b1fa24f4c8e9c158be0455481af29ec0a1f3503f/coverage-7.14.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:01b7733daad0237daa01ef80fe2dfceffc911e6a17fa7b55d14aa8214eaaaecd", size = 263214, upload-time = "2026-05-26T20:41:25.419Z" }, + { url = "https://files.pythonhosted.org/packages/f6/a9/b2493c054c0e01a643266742ab45e15744e60743f9260cd930c7142b1124/coverage-7.14.1-cp314-cp314t-win32.whl", hash = "sha256:6adc5a36984624a70bf11d7184e20fa0a49aa7c47ffab43804106a1a695ea22e", size = 223624, upload-time = "2026-05-26T20:41:27.795Z" }, + { url = "https://files.pythonhosted.org/packages/fc/bd/3e1e6a57fccd2d7c83fcdf338e93ba98eb85c6e877dd34731ac585375490/coverage-7.14.1-cp314-cp314t-win_amd64.whl", hash = "sha256:ddf799247318f34dbcd2efa8c95a8d0642674e926bb1774cf9b63dfd2a389d1c", size = 224728, upload-time = "2026-05-26T20:41:30.098Z" }, + { url = "https://files.pythonhosted.org/packages/bb/d7/31066cf1d2f0c6c797fce911bcfa01dd35642dc6da992a950256097c5860/coverage-7.14.1-cp314-cp314t-win_arm64.whl", hash = "sha256:145986fe66647eb489f18d9a997567a3fd358584c4b5a808769113abc07466af", size = 222752, upload-time = "2026-05-26T20:41:32.123Z" }, { url = "https://files.pythonhosted.org/packages/8a/3c/1a983b9a745d7f83d53f057bcc5bf79ba6a2bbc08266b3f0c7d6fe630c9b/coverage-7.14.1-py3-none-any.whl", hash = "sha256:a252f21c27e38347e60111a3266b03827422a7d5525951aceee313aa68bab1d2", size = 211815, upload-time = "2026-05-26T20:41:34.078Z" }, ] -[[package]] -name = "ct3" -version = "3.4.0.post5" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/96/c2/2a1605af41829cd2a247271b5b6f6b2dbc2e9407df2dd9bcafdceafcd4b3/ct3-3.4.0.post5.tar.gz", hash = "sha256:1c5f2000d52d591703c74f6f5f7ef427ed1b6501be28e3f1634f62c3a5d792e1", size = 303503, upload-time = "2025-11-29T12:38:18.761Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d7/ae/55e9a8ce30c37c43cd0677310bf4d58ed65b8f08880fa3ffccdd86f62125/ct3-3.4.0.post5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:443bff9699ccb0fac142027bea3321a57fb33fe43ec7cccdbac5dd0be337dcbd", size = 863020, upload-time = "2025-11-29T12:39:51.975Z" }, - { url = "https://files.pythonhosted.org/packages/0c/fe/33cab98b7ba9408b837300899bf1bded951bb0e82772c2f4f786951cb5e8/ct3-3.4.0.post5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:61ec5dc8261ff8bb3b0d579ba95f8be9a938251e9a3547cc09ca65de702dbc69", size = 866396, upload-time = "2025-11-29T12:44:12.326Z" }, - { url = "https://files.pythonhosted.org/packages/9f/27/3c3e5398fa49227b2dd67211b4402c84ed9d5b48a4257bf5b1196f9b6a8e/ct3-3.4.0.post5-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:3be2cd9d24b6c6741e90c3f854b20dd019b0c47f7887962972a515b92c35204e", size = 866146, upload-time = "2025-11-29T12:38:20.844Z" }, - { url = "https://files.pythonhosted.org/packages/8b/0e/a065a472cadd8821962aa1f3eb988bcaa93a6cf04eae89b4f72251f5df70/ct3-3.4.0.post5-cp312-cp312-win_amd64.whl", hash = "sha256:9f8ed00963e774c41031727876df99694695b62c791e7de2e4352892ac1e1e06", size = 187276, upload-time = "2025-11-29T12:43:22.548Z" }, - { url = "https://files.pythonhosted.org/packages/a3/85/f0536596eda1884f2c982f675eeaea63de4fd7aeab50785c1006bce1ccdd/ct3-3.4.0.post5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b9a98284dad8fd32e49c05f5223226610cadef69a6a816a4e979fa8af6d870c5", size = 873390, upload-time = "2025-11-29T12:44:00.222Z" }, - { url = "https://files.pythonhosted.org/packages/57/fa/e8aa47b6e4a39ee57618198ec778e7a2aa093f267c3b868bad6230ecfff9/ct3-3.4.0.post5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:371baa49402fdbf50924fa159000c54503071a8354922513c81bdd91234c17d1", size = 876586, upload-time = "2025-11-29T12:43:54.764Z" }, - { url = "https://files.pythonhosted.org/packages/04/1e/eeac3163475c7620621ab582375403a90c5c9d0b0704eab328ca62724383/ct3-3.4.0.post5-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:a85e6d708344ebe93e846d2855d73e0db73b6a8c7aabdc2f4daf27b56abf44b9", size = 876462, upload-time = "2025-11-29T12:38:21.45Z" }, - { url = "https://files.pythonhosted.org/packages/77/a2/67e560a207ef077cff1937c4c983a78935544ea3b02262eed12feba664f7/ct3-3.4.0.post5-cp313-cp313-win_amd64.whl", hash = "sha256:216201ee1978bc653d40ccf7a1cafc5076e81670d64971a5be87e83ade0781fc", size = 187357, upload-time = "2025-11-29T12:42:36.992Z" }, -] - [[package]] name = "cubic" version = "0.7.0" @@ -908,6 +970,8 @@ wheels = [ { url = "https://pypi.nvidia.com/cucim-cu13/cucim_cu13-26.4.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:655292496907f5c3728ed5343806c940f226c2978ba0e6e327d2687284717cbb" }, { url = "https://pypi.nvidia.com/cucim-cu13/cucim_cu13-26.4.0-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fdd2c7ce1029d80a960d3471e42a8f75038c85e02d2c66a803d1c9f8e46b05db" }, { url = "https://pypi.nvidia.com/cucim-cu13/cucim_cu13-26.4.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:692f4c640ee1c5d1d6dd65db6bebf9210f5bd3ac39354be7580a10322ba504a3" }, + { url = "https://pypi.nvidia.com/cucim-cu13/cucim_cu13-26.4.0-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49013b329d4887fc00688c8f5edb61c09541e7dfa2f2bff651981fd23a7f0711" }, + { url = "https://pypi.nvidia.com/cucim-cu13/cucim_cu13-26.4.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f8db4b750de7898050e564804e88b363a927c25d9280dbfa4071ca9bde6a5f74" }, ] [[package]] @@ -915,13 +979,17 @@ name = "cuda-bindings" version = "13.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cuda-pathfinder", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "cuda-pathfinder" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/ce/67/5e7dba1ba576dd73da5dee894ca076ca5e959450dfff66d6d510a255d1f7/cuda_bindings-13.3.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7855c4868aabc0cfae28abbe83d56734bdfbd08f08fc234ac1912a12858bf49", size = 6025351, upload-time = "2026-05-29T23:11:49.685Z" }, { url = "https://files.pythonhosted.org/packages/39/2a/6d2e9047d1fb243dbaa364b01e0297534b9ed7fd27dba1c9f361519cf69b/cuda_bindings-13.3.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e32d08f71ebcdf00f0f41eab2eb37e8da94c8ed411cc9f7f7a019ce6b34abe3a", size = 6657965, upload-time = "2026-05-29T23:11:52.227Z" }, { url = "https://files.pythonhosted.org/packages/cc/6e/2394f8163360f8391f8f1b7e72d300a82724edb81a7b7084c799fbd4c91f/cuda_bindings-13.3.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9efb21c1ee64981e184b9e0ba5eb3179e5ba3d4b51665a6cb52b8ef3d01a7cbf", size = 5920504, upload-time = "2026-05-29T23:11:56.883Z" }, { url = "https://files.pythonhosted.org/packages/34/c2/ef9b6a63f7dc432712a462c816662e662e00d38caa9b861c8c2588195d03/cuda_bindings-13.3.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2732904099e0a4d4db774a5fc6d91ee95fae065b4d2ecabb4968c5fe2406c9d7", size = 6476660, upload-time = "2026-05-29T23:11:59.188Z" }, + { url = "https://files.pythonhosted.org/packages/b1/81/bff68ce829999c1e4209c761bbf903b1c06ec570416ddb25020864ad5907/cuda_bindings-13.3.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ab2f74ed65bfef4163ba07a8db16f1085e0729291db12a2423aff84ee8278b8", size = 6013639, upload-time = "2026-05-29T23:12:03.509Z" }, + { url = "https://files.pythonhosted.org/packages/d4/e0/c8a1f0c8f9ffdea4f5fe6dbab89b326cef4d85caf489dad39e209da89416/cuda_bindings-13.3.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:efd4c814d311ec08c981f6dded1dbe7d4b371067ee4f6c14cccec4bde9590f80", size = 6534419, upload-time = "2026-05-29T23:12:05.633Z" }, + { url = "https://files.pythonhosted.org/packages/52/b8/83b1f563925b290f2d11a01a77a84013ba56052fe3653a5bef3ccfbb43d6/cuda_bindings-13.3.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c3c772dfff49681541d59630c90f858e173ac926b9c593a2b7123f2a1043cc76", size = 5809771, upload-time = "2026-05-29T23:12:10.422Z" }, + { url = "https://files.pythonhosted.org/packages/12/20/e79b4bfe98f075195afb6343d41c498f9dbd2d161d7021d4d28bceb83581/cuda_bindings-13.3.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:36febb7c1079d68a981dbbd8d5a67235b399802b82075c9388624719607e52b9", size = 6358584, upload-time = "2026-05-29T23:12:12.767Z" }, ] [[package]] @@ -942,34 +1010,34 @@ wheels = [ [package.optional-dependencies] cudart = [ - { name = "nvidia-cuda-runtime", marker = "sys_platform == 'linux'" }, + { name = "nvidia-cuda-runtime" }, ] cufft = [ - { name = "nvidia-cufft", marker = "sys_platform == 'linux'" }, + { name = "nvidia-cufft" }, ] cufile = [ - { name = "nvidia-cufile", marker = "sys_platform == 'linux'" }, + { name = "nvidia-cufile" }, ] cupti = [ - { name = "nvidia-cuda-cupti", marker = "sys_platform == 'linux'" }, + { name = "nvidia-cuda-cupti" }, ] curand = [ - { name = "nvidia-curand", marker = "sys_platform == 'linux'" }, + { name = "nvidia-curand" }, ] cusolver = [ - { name = "nvidia-cusolver", marker = "sys_platform == 'linux'" }, + { name = "nvidia-cusolver" }, ] cusparse = [ - { name = "nvidia-cusparse", marker = "sys_platform == 'linux'" }, + { name = "nvidia-cusparse" }, ] nvjitlink = [ - { name = "nvidia-nvjitlink", marker = "sys_platform == 'linux'" }, + { name = "nvidia-nvjitlink" }, ] nvrtc = [ - { name = "nvidia-cuda-nvrtc", marker = "sys_platform == 'linux'" }, + { name = "nvidia-cuda-nvrtc" }, ] nvtx = [ - { name = "nvidia-nvtx", marker = "sys_platform == 'linux'" }, + { name = "nvidia-nvtx" }, ] [[package]] @@ -987,6 +1055,11 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e0/0f/149a9e6c561f44e6522be6c3fdacdaed17d8fd5a1651004a0782ce045502/cupy_cuda13x-14.1.1-cp313-cp313-manylinux2014_aarch64.whl", hash = "sha256:cc671cb766f1c42cb6eed3bf27e9da6092721bcb3d77e09aef28e2f5b089ea38", size = 72811428, upload-time = "2026-06-01T04:54:22.432Z" }, { url = "https://files.pythonhosted.org/packages/80/f6/f4cd043ad8c8e18410e9cea73a8de8778a0a05c705b8505729a794758bf1/cupy_cuda13x-14.1.1-cp313-cp313-manylinux2014_x86_64.whl", hash = "sha256:ff4526725c1398ea19d578044737aa24859b08e1f469aba0ca45dfd6f9aa505d", size = 69094726, upload-time = "2026-06-01T04:54:26.424Z" }, { url = "https://files.pythonhosted.org/packages/54/64/f2b60a0f4d73820d774906bf8684df0c8494820d78b3494121c7ec57ee25/cupy_cuda13x-14.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:54949b4e4f90e3588eeef25b55037f156578364e4835eb9ae1b93e236f2e58d5", size = 35171412, upload-time = "2026-06-01T04:54:31.313Z" }, + { url = "https://files.pythonhosted.org/packages/fd/ca/9bc8d6d40003640653161e2dba78740f2055df8bb48e216eed5584cecc3c/cupy_cuda13x-14.1.1-cp314-cp314-manylinux2014_aarch64.whl", hash = "sha256:8b068f6958811bc50d81bd0a83267ec4cffc3d7e842120b9646ec547f5a69298", size = 72680680, upload-time = "2026-06-01T04:54:35.077Z" }, + { url = "https://files.pythonhosted.org/packages/e8/2d/8c79c577e9b35c60e5600217d1a849ab76c18a289f99a4145aa85388a531/cupy_cuda13x-14.1.1-cp314-cp314-manylinux2014_x86_64.whl", hash = "sha256:39f8aeeb5bad16603956f8ec00094e058a9dd5db92ab514975686750363c3692", size = 68432306, upload-time = "2026-06-01T04:54:38.882Z" }, + { url = "https://files.pythonhosted.org/packages/c4/03/8d4d77138eb5f60a2a1fb5484a89dad2bc6bc6283682179994d722cfb4b5/cupy_cuda13x-14.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:dae6f77edfe96ab8e014d3e589dca33906d212fdf8f72e66850d4612bc031783", size = 35323057, upload-time = "2026-06-01T04:54:42.541Z" }, + { url = "https://files.pythonhosted.org/packages/c4/c4/eb46fec30fffd7a57a80cc7f027e50a1d530b332e81362a8b874905da2d1/cupy_cuda13x-14.1.1-cp314-cp314t-manylinux2014_aarch64.whl", hash = "sha256:509f378c865c0b6bc9ed1dfe9e94b08b4511e9865363fdac55f9d66fe341e91d", size = 72984246, upload-time = "2026-06-01T04:54:46.464Z" }, + { url = "https://files.pythonhosted.org/packages/24/59/e0098ca2e1ba99a0086ad4b515b2d7dbb8ae0f13b9721c02eed0db4adec5/cupy_cuda13x-14.1.1-cp314-cp314t-manylinux2014_x86_64.whl", hash = "sha256:6c0d19789e9f9515988d51dffaff70af8b3dcdddcdf2fbafa9eff08df7be0a51", size = 68662887, upload-time = "2026-06-01T04:54:50.932Z" }, ] [[package]] @@ -998,35 +1071,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" }, ] -[[package]] -name = "cython" -version = "3.1.8" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b4/a4/ec55945b52d0b888e2a090450a5524001bfa17c8b68348379a154badb850/cython-3.1.8.tar.gz", hash = "sha256:518475fbe633ba30c1577669f417440f41e1a23ad6b6e2dbb20703cd457f04ef", size = 3193040, upload-time = "2026-01-03T18:30:25.181Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/05/6b/0a64844db2ba8a15f4108700afde4b8f73352fdbf73516ac26d5a025ea12/cython-3.1.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:850503d88092af519662cf66aef26f95db677bdbba55a482ae8658c5b3ac6ad4", size = 3059306, upload-time = "2026-01-03T18:31:20.734Z" }, - { url = "https://files.pythonhosted.org/packages/72/fb/7448e6ba0baf50df463ee0e4f8c332750778960f21c7e73b574e90dd85fb/cython-3.1.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0aa5443cc8bfc937369871fbba59990b36cd9af73ed70db9052ac980d44492e4", size = 2967016, upload-time = "2026-01-03T18:31:22.918Z" }, - { url = "https://files.pythonhosted.org/packages/0f/a6/a5ae92b551ea07dcb106c39835d27e8133d3c80f7f752161795e2d5b8deb/cython-3.1.8-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d9029c0eb895a56746ca0d4b3a6a0a57e4c90f2599204e99f7033818ea1c3022", size = 3385245, upload-time = "2026-01-03T18:31:24.544Z" }, - { url = "https://files.pythonhosted.org/packages/bf/e0/97031ea58d8e68d9465039a9cb7ef0f94dae301907fc352d69f973587008/cython-3.1.8-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d9cd8d1194ab8f52898be10d252ff17360e0af0e2a6662a8d9688fdd8e4cdd7e", size = 3163833, upload-time = "2026-01-03T18:31:28.108Z" }, - { url = "https://files.pythonhosted.org/packages/a9/5e/b590aff6c332fb6bf5c12d2fae0383f6e866b47d0b1efd8bdc9443198ce0/cython-3.1.8-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d1bcbed7578f1986a61471476ea5deb0806591aa477230954dd9898a25d0f4e2", size = 3314265, upload-time = "2026-01-03T18:31:29.758Z" }, - { url = "https://files.pythonhosted.org/packages/1d/82/54aa9d4cf913a68bc9d2f96c3d24024bb032b1d864bbe2b238571f85743d/cython-3.1.8-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d973d25a767abcf977737221dc11befda98daf2573e8bc3c2e6995479505f92a", size = 3176271, upload-time = "2026-01-03T18:31:31.817Z" }, - { url = "https://files.pythonhosted.org/packages/03/c0/306dbd4b795d61f1452fb955b6a3872a02de060cbfe84c27e33b7c8ef987/cython-3.1.8-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a9288fa02135743719942deaeb44976399a5785a59f076221ef7e9b22cd0d571", size = 3397778, upload-time = "2026-01-03T18:31:33.48Z" }, - { url = "https://files.pythonhosted.org/packages/e1/4c/9f4955fd1f14c5b05b72bb060b6568ba858b90084d7ee8f0744465458c0d/cython-3.1.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7eb8448eb1c3632c4684ee98db935cf7d3b54fb528a7a455841789316667cd88", size = 3324441, upload-time = "2026-01-03T18:31:35.774Z" }, - { url = "https://files.pythonhosted.org/packages/df/0f/036800c421ddf465312fa26872835f2388e8f4247aac1b9ac31527738d83/cython-3.1.8-cp312-cp312-win32.whl", hash = "sha256:c6b74c42bf6b2381d9fdb65f7eda44bcc5c29e4e96c677167495d2cd882d7a3c", size = 2483909, upload-time = "2026-01-03T18:31:37.72Z" }, - { url = "https://files.pythonhosted.org/packages/aa/77/59db4b7e09374a718564a4a9758c88285131d74cecde275991a2b513b05e/cython-3.1.8-cp312-cp312-win_amd64.whl", hash = "sha256:cae61e8e730bfc7de917204c8b7c1ca8e3e0d134dcaa55a2e2ef98de741590fb", size = 2701034, upload-time = "2026-01-03T18:31:39.58Z" }, - { url = "https://files.pythonhosted.org/packages/40/eb/363c88e2038c7f8acdf0d8a35a79aee9c738946f613ba070ab4ab331ca2f/cython-3.1.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5e10d15d2e7f245e61dec89c27da377c2136c08efb6cc2c50baea25b39aab3f9", size = 3047679, upload-time = "2026-01-03T18:31:41.607Z" }, - { url = "https://files.pythonhosted.org/packages/f4/ea/31560e57d1cbe5e7b18a949e2103b8e08617a6796356f4771200b7b5dff5/cython-3.1.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e04bb68f932853a38bab7f7c024088a9f6510ccb45ad9a12cca6ebb09ec7a25f", size = 2955139, upload-time = "2026-01-03T18:31:45.551Z" }, - { url = "https://files.pythonhosted.org/packages/b6/77/523f572b65ebe160493a834652fa829d955c97dccef36f8f0d2bb82efbc9/cython-3.1.8-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:85c39a8005f314ee90ab271d2b68b6725f94fc08c4e6728417b64704a7ebce04", size = 3359630, upload-time = "2026-01-03T18:31:48.025Z" }, - { url = "https://files.pythonhosted.org/packages/53/58/a3d7f9a0318c6334cb84b8029858dcbc64de0968fa7dde54ea54cdc8585b/cython-3.1.8-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1be05353f84e6a32cbae5869da1af72d356cc73a6dfa521423543688f6b59d67", size = 3153394, upload-time = "2026-01-03T18:31:49.661Z" }, - { url = "https://files.pythonhosted.org/packages/97/59/aaa43285de4970857787c4f43ae5a4f6bb40001c161552e1fe1b6bb5274b/cython-3.1.8-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:03959ed8996e16550267469187442f3926ea3ba4bb220a06714e6203e4cb6017", size = 3304486, upload-time = "2026-01-03T18:31:51.763Z" }, - { url = "https://files.pythonhosted.org/packages/fa/56/45029eaa65b91579f557cd2c42b1dcabb0a4c2bff1be3b6b7e19743ff0f8/cython-3.1.8-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:354f43c6d0e312f650ed39c683e550f669ed18f49ca0bd5772f207ef31f8980c", size = 3169675, upload-time = "2026-01-03T18:31:53.448Z" }, - { url = "https://files.pythonhosted.org/packages/2a/bd/d6ad2772c38fba22820ee9ba4a0b647232ebdcb16138751e70c02eafe286/cython-3.1.8-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b690edfa6b333f6139e8ecaa5af8fe87ea591f04d2f2b6a492ed4f2896d818c4", size = 3373228, upload-time = "2026-01-03T18:31:55.571Z" }, - { url = "https://files.pythonhosted.org/packages/62/83/03f06cf647a0f579cfcfd7d336491426c95838cf9f3e4d6cb9e2c3c1e811/cython-3.1.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:65d0cf78a14616cb05ff21f63b47bf369e23f353acd51420526c5eb3029f682a", size = 3316815, upload-time = "2026-01-03T18:31:57.929Z" }, - { url = "https://files.pythonhosted.org/packages/3a/9d/2c5088d4c2c9d39692c5aca52fad35ade256d871ebecde61171acb3925fd/cython-3.1.8-cp313-cp313-win32.whl", hash = "sha256:34eb6dfaa0786a7477aaac86696f26efc052cda586d4f97a9d1d2c6b2ff6d26d", size = 2477612, upload-time = "2026-01-03T18:31:59.725Z" }, - { url = "https://files.pythonhosted.org/packages/00/b0/4cb436aab34f082454cf38cd21ed64021450fe51d1006aecaba62b6ac2c1/cython-3.1.8-cp313-cp313-win_amd64.whl", hash = "sha256:fc3cbaee08d424d2852c7b134ca432501792f67021b73a029cf2f13fb6172423", size = 2698217, upload-time = "2026-01-03T18:32:01.635Z" }, - { url = "https://files.pythonhosted.org/packages/5b/c7/b81516c9bb5da55d327b3cf2f33f39217719e73b524ab49a4028e18b6a66/cython-3.1.8-py3-none-any.whl", hash = "sha256:f36368c1d7ea4003c52e9e93f3556074a631a6482f8a32e781cb073e211e4df9", size = 1223843, upload-time = "2026-01-03T18:30:22.229Z" }, -] - [[package]] name = "cytoland" source = { editable = "applications/cytoland" } @@ -1121,6 +1165,10 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/48/57/412421516afc3055fa577516f00beec3d663f9b0ab330639547ae6c57720/debugpy-1.8.21-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:ecbd158386c31ffe71d46f72d44d56e66331ab9b16cad649156d514368f23ab2", size = 3962096, upload-time = "2026-06-01T19:30:59.235Z" }, { url = "https://files.pythonhosted.org/packages/c1/62/2c616337cf6ba7b07ebbc97f02c6c945a8e2f76b365e33ee809c32ee36d1/debugpy-1.8.21-cp313-cp313-win32.whl", hash = "sha256:2c2ae706dec41d99a9ca1f7ebc987a83e65578363be6f6b3ac9067504917fae1", size = 5336288, upload-time = "2026-06-01T19:31:00.79Z" }, { url = "https://files.pythonhosted.org/packages/f8/99/9175103392f84c4b1bf7622888cdc68da07f0ff7d9e581266428f6776033/debugpy-1.8.21-cp313-cp313-win_amd64.whl", hash = "sha256:aa648733047443eb1d07682c4ef287d36a54507b643ffdf38b09a3ef002c72a0", size = 5376567, upload-time = "2026-06-01T19:31:02.56Z" }, + { url = "https://files.pythonhosted.org/packages/ce/3d/f4bbb323a548bfab2af3d6b4ffd9bf22636e55956a1285d317a1de643aad/debugpy-1.8.21-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:9bb2a685287a2ac9b181cde89edcec64845cb51de7faaa75badb9a698bc24782", size = 2477209, upload-time = "2026-06-01T19:31:04.157Z" }, + { url = "https://files.pythonhosted.org/packages/8c/2d/6e7ec524984a1702777868de49a4c53202bddac2a432a76a093469587750/debugpy-1.8.21-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:3d6922439bf33fd38a3e2c447869ebc7b97da5cd3d329ff1ef9bc06c4903437e", size = 3927115, upload-time = "2026-06-01T19:31:05.863Z" }, + { url = "https://files.pythonhosted.org/packages/97/47/d1aa6d64005a98a9144647d99306b419396f9ad7bf1d73c119e17a81fb4d/debugpy-1.8.21-cp314-cp314-win32.whl", hash = "sha256:15d4963bd5ffa48f0da0947fd06757fa7621945048a14ad7705431566d3c0e7c", size = 5336724, upload-time = "2026-06-01T19:31:07.711Z" }, + { url = "https://files.pythonhosted.org/packages/5f/67/b905b90d163af11878c1af8abafa4a25206335e112e284e413454543a6da/debugpy-1.8.21-cp314-cp314-win_amd64.whl", hash = "sha256:fe0744a12353406de0ae8ccff0d0a4a666f00801a3db8fd04e7a5f761cd520e8", size = 5373803, upload-time = "2026-06-01T19:31:09.469Z" }, { url = "https://files.pythonhosted.org/packages/95/51/67e7cf11a53e40694f720457d5b3a1cdaaa3d5a9a633e482f225456b93ff/debugpy-1.8.21-py2.py3-none-any.whl", hash = "sha256:b1e37d333663c8851516a47364ef473da127f9caebe4417e6df6f5825a7e9a92", size = 5352888, upload-time = "2026-06-01T19:31:25.186Z" }, ] @@ -1192,15 +1240,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a7/5f/ed01f9a3cdffbd5a008556fc7b2a08ddb1cc6ace7effa7340604b1d16699/docstring_parser-0.18.0-py3-none-any.whl", hash = "sha256:b3fcbed555c47d8479be0796ef7e19c2670d428d72e96da63f3a40122860374b", size = 22484, upload-time = "2026-04-14T04:09:18.638Z" }, ] -[[package]] -name = "docutils" -version = "0.22.4" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ae/b6/03bb70946330e88ffec97aefd3ea75ba575cb2e762061e0e62a213befee8/docutils-0.22.4.tar.gz", hash = "sha256:4db53b1fde9abecbb74d91230d32ab626d94f6badfc575d6db9194a49df29968", size = 2291750, upload-time = "2025-12-18T19:00:26.443Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/02/10/5da547df7a391dcde17f59520a231527b8571e6f46fc8efb02ccb370ab12/docutils-0.22.4-py3-none-any.whl", hash = "sha256:d0013f540772d1420576855455d050a2180186c91c15779301ac2ccb3eeb68de", size = 633196, upload-time = "2025-12-18T19:00:18.077Z" }, -] - [[package]] name = "donfig" version = "0.8.1.post1" @@ -1230,6 +1269,11 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ed/7f/06ce3d5ce51a959be0534584ad2556e6c8be966ef1218a866c6c3d62e3c5/dtaidistance-2.4.0-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:94b841d6575e3ad715b4e213f0f04de25e23c2da3ac21ee9c6775b38f5bdfecf", size = 1738478, upload-time = "2026-02-13T08:14:51.715Z" }, { url = "https://files.pythonhosted.org/packages/db/8e/6c8a5c7710f9f5e3805281974ce8fea4ad0334c00a1e0f977977c045a594/dtaidistance-2.4.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b0f2a65628aea82175e7f8c5e96faf5372c933ed40e2e39a84957d8fe305158d", size = 4341606, upload-time = "2026-02-12T22:23:46.977Z" }, { url = "https://files.pythonhosted.org/packages/9f/b6/7f77c6773380742660d09f379d43814b448296fc24c3fb1de15a3d813311/dtaidistance-2.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:b8c9ef4c7270d1a192e8f1b481c2e10e63c33c6e7edfc507acac7f3fdc19949f", size = 1441578, upload-time = "2026-02-12T22:23:48.897Z" }, + { url = "https://files.pythonhosted.org/packages/05/72/ac72a2e196c66c627c1f51684ffa2fd782e9cb042baa29898206f79b0d86/dtaidistance-2.4.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:bda9849cd22800cd8b3c6abf29574db241458823814cd37302d01df99474175a", size = 2136045, upload-time = "2026-02-12T22:23:50.1Z" }, + { url = "https://files.pythonhosted.org/packages/30/30/60f941b3fed3d8b94e7315a71b8f87294f2e053c1f3c19e53f7b6cc33689/dtaidistance-2.4.0-cp314-cp314-macosx_26_0_arm64.whl", hash = "sha256:b5aa878c57f779cb9e141c0b4b1bc6b5be9c1721b349d153758112854a1b24cf", size = 1676822, upload-time = "2026-02-13T08:14:56.305Z" }, + { url = "https://files.pythonhosted.org/packages/b9/82/b805e66d3b05e2cfc4e209b7d7f62ac31fb7e72615c3532c7edb0bf1943a/dtaidistance-2.4.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a2d7d26b9023788f62e5f245db5b78b68aacde67e5aeaa75906ce7ddb251da7f", size = 4328390, upload-time = "2026-02-12T22:23:52.115Z" }, + { url = "https://files.pythonhosted.org/packages/2c/89/da956340797c0ea022a35b6b0df9a118cc4427401d9a8119dc104d4b48de/dtaidistance-2.4.0-cp314-cp314-win_amd64.whl", hash = "sha256:3a35f2957bbf50b068b0b90f5cc9b442bf9b2a90b855e713811b8badf89a668d", size = 1462169, upload-time = "2026-02-12T22:23:53.598Z" }, + { url = "https://files.pythonhosted.org/packages/a7/02/16088a7bd17340a4e600f49bf4da16a9741ddbb737202a91363407e993b2/dtaidistance-2.4.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e083a5163c780a5b711d970c190d3eca83ebc0ec86e453e6f56d63b1d6d78139", size = 4332943, upload-time = "2026-02-12T22:23:55.009Z" }, ] [[package]] @@ -1252,6 +1296,13 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/63/4c/0907c3f76adb9dd90e67610b31e0304a35814e65c4c41a354a262c09b885/duckdb-1.5.3-cp313-cp313-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:787df63824f07bf18022dbc3b8ca4b2bfab0ebe616464f55c6e8cd0f59ea762e", size = 21453266, upload-time = "2026-05-20T11:55:04.5Z" }, { url = "https://files.pythonhosted.org/packages/6d/9c/d2f23a7803ddbbd9413f7572ecf66a15120ed5ced7ce5c73e698c1406b76/duckdb-1.5.3-cp313-cp313-win_amd64.whl", hash = "sha256:bb5bb5dcdd09d62ee60f0ddbbef918e71cce304ffe28428b1131949d39ffaabf", size = 13118640, upload-time = "2026-05-20T11:55:07.389Z" }, { url = "https://files.pythonhosted.org/packages/27/d5/7ba2316415bcdab6edd765bbbe35c2ca8a3800f2fe695cd70e3cdb997f09/duckdb-1.5.3-cp313-cp313-win_arm64.whl", hash = "sha256:2fa17ecdd5d3db122836cb71bb93601c2106a3be883c17dffddc02fbf3fa7888", size = 13926409, upload-time = "2026-05-20T11:55:10.166Z" }, + { url = "https://files.pythonhosted.org/packages/a5/c2/d4b6f8a5e4d3bc25773be6da76a99d9661ebbf3552c007c460d2dd59dbf8/duckdb-1.5.3-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:4bfa9a4dadf71e83e2c4eaca2f9421c82a54defecc1b0b4c0be95e2389dec4fe", size = 32636685, upload-time = "2026-05-20T11:55:13.158Z" }, + { url = "https://files.pythonhosted.org/packages/42/58/e835c8298979d29db7a62cb5acc29e9b57aeaca7cdde2fcd3ac980f5cb18/duckdb-1.5.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:aea7baf67ad7e1829ac76f67d7dcbd7fb1f57c3eb179d55ac30952df4709ae30", size = 17308134, upload-time = "2026-05-20T11:55:16.194Z" }, + { url = "https://files.pythonhosted.org/packages/c9/46/617b51363f5613418c8b224b3cce16b58e6dde80904566bec232579c1d4e/duckdb-1.5.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0b0b4f088a65d77e1217ce5d7eff889e63fedc44281200d899ff47c84d8ff836", size = 15449891, upload-time = "2026-05-20T11:55:18.687Z" }, + { url = "https://files.pythonhosted.org/packages/b3/72/354146656e8d9ba3853d3a5ee80a481b8c5f70edfc3d5ae80a8c4479c967/duckdb-1.5.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fe8d0c1f6a120aa03fa6e0d03897c71a1842e6cf7afd31d181348391f7108fe1", size = 19338499, upload-time = "2026-05-20T11:55:21.34Z" }, + { url = "https://files.pythonhosted.org/packages/56/8f/65fc623b51448f2bfba1a9ec6ab3debb4664c0876c0113a5e782600b53ac/duckdb-1.5.3-cp314-cp314-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d0405eae18ec6e8210a471c97dbfe87a7e4d605274b7fe572a1f276e92158f13", size = 21455828, upload-time = "2026-05-20T11:55:23.847Z" }, + { url = "https://files.pythonhosted.org/packages/2b/db/d0274cbe9f5fe219f77c0bdf900ac77103569e83c102a4225ce04cbc607d/duckdb-1.5.3-cp314-cp314-win_amd64.whl", hash = "sha256:33ae08b3e818d7613d8936744b67718c2062c2f530376895bfd89efb51b81538", size = 13640011, upload-time = "2026-05-20T11:55:26.276Z" }, + { url = "https://files.pythonhosted.org/packages/07/5d/8f1899b8bef291caf953992fcd6c24df9f29387a35645e58c2504a5ca473/duckdb-1.5.3-cp314-cp314-win_arm64.whl", hash = "sha256:746433e49bbc667b4df283153415fbe37e9083e0eff6c3cd6e54de7536869cd4", size = 14411554, upload-time = "2026-05-20T11:55:29.037Z" }, ] [[package]] @@ -1483,156 +1534,12 @@ test = [ ] [[package]] -name = "edt" -version = "3.1.1" +name = "execnet" +version = "2.1.2" source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "numpy" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/a5/ca/432c11df2a261fcae71dea11eeabfc5affd8ada22aaafa378212c1e9c9e2/edt-3.1.1.tar.gz", hash = "sha256:4b0ab5d898077eda76d1ebdec6e3a4085fd33d4c85195d71abf464ff225915c5", size = 3234159, upload-time = "2026-03-01T05:20:30.695Z" } +sdist = { url = "https://files.pythonhosted.org/packages/bf/89/780e11f9588d9e7128a3f87788354c7946a9cbb1401ad38a48c4db9a4f07/execnet-2.1.2.tar.gz", hash = "sha256:63d83bfdd9a23e35b9c6a3261412324f964c2ec8dcd8d3c6916ee9373e0befcd", size = 166622, upload-time = "2025-11-12T09:56:37.75Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/8b/e2/f54b48f0385898b1e5ee406cf99394e7764c9d77fff1741f0fb979f784d0/edt-3.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7234587b35ce80dcf15ad7c81b45d79d75822c8b6b723e100573a5101bde90d9", size = 271864, upload-time = "2026-03-01T05:19:37.877Z" }, - { url = "https://files.pythonhosted.org/packages/2f/fe/3d0bb0dcb15382f290fc747d0709fe3d72adf5dad3f9f86d7743845d3a42/edt-3.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9850d32ed0e39fae0677a3ec33202a2f4a1be8bf19d0a9371b555adbca649f56", size = 253569, upload-time = "2026-03-01T05:19:39.059Z" }, - { url = "https://files.pythonhosted.org/packages/05/b1/5d88ed781e1b72d24c9ff0a08fae46b7d704d1d057f1888fb922345c79f2/edt-3.1.1-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ec432bdf8441bdf7d98bf3295280662dbba65c9dcecc54d8713b5238ffeb16e7", size = 2876532, upload-time = "2026-03-01T05:19:40.457Z" }, - { url = "https://files.pythonhosted.org/packages/f1/79/dad79e48da52bed034fcf3589d4f2d97a77d010b7776ffd0d29f6d63516b/edt-3.1.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2f5e28666d723e577327d4fc2ce5c4fd572e20299a2b14e5bb829a675a95340e", size = 2969706, upload-time = "2026-03-01T05:19:42.217Z" }, - { url = "https://files.pythonhosted.org/packages/21/4d/1509a586dddd92288410d5de605c38f83fb1f1e7572193ca941bd2a88c86/edt-3.1.1-cp312-cp312-win32.whl", hash = "sha256:d713a4b0a8e097cb5bf2c7fdebd9dc76f6668de7c4e62e0ca846b68ddbd6f64d", size = 170753, upload-time = "2026-03-01T05:19:44.335Z" }, - { url = "https://files.pythonhosted.org/packages/24/88/623a76e7451d9b147bf8f025921c42063e85eac3729e88807af3336bab46/edt-3.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:da204a3b1e2b98a414a0d45a5e3806b91e0e16daf43581d98e7adef74f960769", size = 206157, upload-time = "2026-03-01T05:19:43.502Z" }, - { url = "https://files.pythonhosted.org/packages/2a/3a/46f02072334c42146ffd241251ac5ca795e84f6d6ffa87b95df37d047e64/edt-3.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:05959ab8c0f9ce1a1b2736d27c83780f1a2ab77232428f5a606d5e447b7f9a3a", size = 270847, upload-time = "2026-03-01T05:19:46.505Z" }, - { url = "https://files.pythonhosted.org/packages/fa/15/92f5dceb6b953f1c31b4b627466977fc5a3d18514eeed27f7be1d287b105/edt-3.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6b6922e81f1b47832a7a71302eb79372f3aea2a0bbca6bb6b6f6275df18bdaab", size = 252991, upload-time = "2026-03-01T05:19:47.489Z" }, - { url = "https://files.pythonhosted.org/packages/0a/eb/37e1a719432e747aa6b8d2046eae910f76640bd9be4d71f667cc3dda2356/edt-3.1.1-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:467ce55f466ce21c5fb90462cabf82c73796920a8a9d5c0f655b01c6f427c7c3", size = 2867610, upload-time = "2026-03-01T05:19:49.352Z" }, - { url = "https://files.pythonhosted.org/packages/c0/16/35778deac2353ed385e81bda4dfd2eefcc1c0c1e1c083f4cb39ef0025d18/edt-3.1.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b464bd8bb6e14edfc07f8c1382700446bc20a2b521ec494f3de1fd5d20471cf3", size = 2954115, upload-time = "2026-03-01T05:19:52.558Z" }, - { url = "https://files.pythonhosted.org/packages/22/87/33fa8d7787489dd21957de56fbc6ad655dd156382b78e9ce2aeef125a044/edt-3.1.1-cp313-cp313-win32.whl", hash = "sha256:06c0ff97bc705803880a153c34b12b8245da51951198f4689942020a9bfcf6ff", size = 170606, upload-time = "2026-03-01T05:19:54.967Z" }, - { url = "https://files.pythonhosted.org/packages/fb/cf/ce2e98dc0b060c705c321090d9d9fcd9ab39b041309ccc0ca0ae9009cc94/edt-3.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:d6804fe5fcbd7d03813eb48fc33cdfd25cb166d0241768969ee24f209fca07de", size = 206561, upload-time = "2026-03-01T05:19:53.741Z" }, -] - -[[package]] -name = "eet-features" -version = "0.1.0" -source = { editable = "../../../../../home/eduardo.hirata/repos/eet_features" } -dependencies = [ - { name = "dask", extra = ["array"] }, - { name = "h5py" }, - { name = "numpy" }, - { name = "polars" }, - { name = "scikit-image" }, - { name = "scipy" }, - { name = "toolz" }, - { name = "tracksdata" }, -] - -[package.metadata] -requires-dist = [ - { name = "dask", extras = ["array"], specifier = ">=2022.3.0" }, - { name = "h5py", specifier = ">=3.9.0" }, - { name = "numpy", specifier = ">=1.24.0" }, - { name = "polars", specifier = ">=0.19.0" }, - { name = "pre-commit", marker = "extra == 'dev'", specifier = ">=3.5.0" }, - { name = "pytest", marker = "extra == 'dev'", specifier = ">=7.4.0" }, - { name = "pytest-cov", marker = "extra == 'dev'", specifier = ">=4.1.0" }, - { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.1.0" }, - { name = "scikit-image", specifier = ">=0.21.0" }, - { name = "scipy", specifier = ">=1.11.0" }, - { name = "toolz", specifier = ">=0.11.0" }, - { name = "tracksdata", git = "https://github.com/royerlab/tracksdata?rev=b605d2d6aa4bd12a31c07b499f5acf8411bac518" }, -] -provides-extras = ["dev"] - -[[package]] -name = "eet-inference" -version = "0.1.0" -source = { editable = "../../../../../home/eduardo.hirata/repos/eet_inference" } -dependencies = [ - { name = "dask" }, - { name = "eet-features" }, - { name = "gurobipy" }, - { name = "numpy" }, - { name = "polars" }, - { name = "pydantic" }, - { name = "pyyaml" }, - { name = "rich" }, - { name = "spatial-graph" }, - { name = "torch" }, - { name = "tracksdata" }, - { name = "typer" }, -] - -[package.metadata] -requires-dist = [ - { name = "dask" }, - { name = "eet-features", specifier = ">=0.1.0" }, - { name = "gurobipy", specifier = ">12.0.1,<13.0.0" }, - { name = "numpy", specifier = ">=1.24.0" }, - { name = "polars", specifier = ">=1.0.0" }, - { name = "pre-commit", marker = "extra == 'dev'", specifier = ">=3.5.0" }, - { name = "pydantic", specifier = ">=2.12.5" }, - { name = "pytest", marker = "extra == 'dev'", specifier = ">=7.4.0" }, - { name = "pytest-cov", marker = "extra == 'dev'", specifier = ">=4.1.0" }, - { name = "pyyaml", specifier = ">=6.0.3" }, - { name = "rich", specifier = ">=14.3.1" }, - { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.1.0" }, - { name = "spatial-graph", specifier = ">=0.0.5" }, - { name = "torch", specifier = ">=2.0.0" }, - { name = "tracksdata" }, - { name = "typer", specifier = ">=0.21.1" }, -] -provides-extras = ["dev"] - -[[package]] -name = "eet-tracking" -source = { editable = "applications/eet" } -dependencies = [ - { name = "dask", extra = ["array"] }, - { name = "eet-features" }, - { name = "eet-inference" }, - { name = "iohub" }, - { name = "napari", extra = ["pyqt5"] }, - { name = "napari-geff" }, - { name = "pyyaml" }, - { name = "rich" }, - { name = "torch" }, - { name = "ultrack" }, - { name = "ultrack-td" }, -] - -[package.dev-dependencies] -dev = [ - { name = "ipykernel" }, - { name = "pytest" }, - { name = "pytest-cov" }, -] -jupyter = [ - { name = "ipykernel" }, -] -test = [ - { name = "pytest" }, - { name = "pytest-cov" }, -] - -[package.metadata] -requires-dist = [ - { name = "dask", extras = ["array"] }, - { name = "eet-features", editable = "../../../../../home/eduardo.hirata/repos/eet_features" }, - { name = "eet-inference", editable = "../../../../../home/eduardo.hirata/repos/eet_inference" }, - { name = "iohub", specifier = ">=0.3.3" }, - { name = "napari", extras = ["pyqt5"] }, - { name = "napari-geff", editable = "../../../../../home/eduardo.hirata/repos/napari-geff" }, - { name = "pyyaml" }, - { name = "rich" }, - { name = "torch", specifier = ">=2.0.0" }, - { name = "ultrack", editable = "../../../../../home/eduardo.hirata/repos/ultrack" }, - { name = "ultrack-td", editable = "../../../../../home/eduardo.hirata/repos/ultrack-td" }, -] - -[package.metadata.requires-dev] -dev = [ - { name = "ipykernel" }, - { name = "pytest", specifier = ">=9.0.2" }, - { name = "pytest-cov", specifier = ">=7" }, -] -jupyter = [{ name = "ipykernel" }] -test = [ - { name = "pytest", specifier = ">=9.0.2" }, - { name = "pytest-cov", specifier = ">=7" }, + { url = "https://files.pythonhosted.org/packages/ab/84/02fc1827e8cdded4aa65baef11296a9bbe595c474f0d6d758af082d849fd/execnet-2.1.2-py3-none-any.whl", hash = "sha256:67fba928dd5a544b783f6056f449e5e3931a5c378b128bc18501f7ea79e296ec", size = 40708, upload-time = "2025-11-12T09:56:36.333Z" }, ] [[package]] @@ -1644,31 +1551,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" }, ] -[[package]] -name = "fastapi" -version = "0.138.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "annotated-doc" }, - { name = "pydantic" }, - { name = "starlette" }, - { name = "typing-extensions" }, - { name = "typing-inspection" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/8a/c9/5e8defe249899c0dc900643695fc07829a67fc88b4ff2cdb03fcbdbf5a4b/fastapi-0.138.1.tar.gz", hash = "sha256:96e3702dce09ee0dce48856135620d3d865ca684a79fe7513fd7b13a12f82862", size = 419646, upload-time = "2026-06-25T15:40:42.115Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/38/a9/69a6924f645eb4dd8cd625bf255b3625990eb3e14e073438a53c405dcd3e/fastapi-0.138.1-py3-none-any.whl", hash = "sha256:b994cae7ba8b82c976a728b544244de31333fa5f7d261f9a1dffe526444cae23", size = 129182, upload-time = "2026-06-25T15:40:40.771Z" }, -] - -[[package]] -name = "fasteners" -version = "0.20" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/2d/18/7881a99ba5244bfc82f06017316ffe93217dbbbcfa52b887caa1d4f2a6d3/fasteners-0.20.tar.gz", hash = "sha256:55dce8792a41b56f727ba6e123fcaee77fd87e638a6863cec00007bfea84c8d8", size = 25087, upload-time = "2025-08-11T10:19:37.785Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/51/ac/e5d886f892666d2d1e5cb8c1a41146e1d79ae8896477b1153a21711d3b44/fasteners-0.20-py3-none-any.whl", hash = "sha256:9422c40d1e350e4259f509fb2e608d6bc43c0136f79a00db1b49046029d0b3b7", size = 18702, upload-time = "2025-08-11T10:19:35.716Z" }, -] - [[package]] name = "fastjsonschema" version = "2.21.2" @@ -1699,6 +1581,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/16/41/e70db40a9d1a2cb8d4bbd5416f1c3607c52beb482fdc28ca7c4ef05630c9/fastremap-1.19.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:be07b2f2f240947563e3959e561eadd3c6574254d41adbf7146cb15b4bce8f92", size = 6976692, upload-time = "2026-04-29T00:39:19.867Z" }, { url = "https://files.pythonhosted.org/packages/c2/66/9bd9e8a3485876a9cb520fdb0616999db98500206180bed88ad8d3f5be71/fastremap-1.19.0-cp313-cp313-win32.whl", hash = "sha256:6619a877a16e732a4cc909268b10ec4dccffed70b3eb05eb6d259f5282094883", size = 432989, upload-time = "2026-04-29T00:39:24.756Z" }, { url = "https://files.pythonhosted.org/packages/bd/17/5f82236f7b742753204d1388ecac5b9b2cc8d3043fbfb7176f0df071bdad/fastremap-1.19.0-cp313-cp313-win_amd64.whl", hash = "sha256:bba7d43fe3770960086cc69fcaca63768dd149159df42e02ef05fa1b8b2d79c0", size = 602795, upload-time = "2026-04-29T00:39:23.397Z" }, + { url = "https://files.pythonhosted.org/packages/77/ef/65cad42fe60d4b4611a1e95ba2d406d202e825de663d86961be82ee54b3b/fastremap-1.19.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:00197b4b2609ec8a14953d3af4780ed4d3b2dedb6fa612c8854217d4673e07a8", size = 700693, upload-time = "2026-04-29T00:39:26.335Z" }, + { url = "https://files.pythonhosted.org/packages/bb/ab/b9d5a26e3b3ab4bd624e610e0a71e47f73917edfbd4fbb70a26ef5fd4a98/fastremap-1.19.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:8b8ba5e9df854c7fef5a77a48be5f892520d8222c6f4602c2de41f6966c9cefb", size = 591630, upload-time = "2026-04-29T00:39:28.18Z" }, + { url = "https://files.pythonhosted.org/packages/63/7d/dd7b1938b142978ee2dc1e656d195aedb7527affb108f31124a884d66164/fastremap-1.19.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:da8b90e6e8c6e32b9e18e490509ce098097bcd9cd0a30280b381460b507e98f9", size = 6796504, upload-time = "2026-04-29T00:39:32.508Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ea/101b1aea304127b532642f7985a816a65af29953de36e83877a2cc2a7a3e/fastremap-1.19.0-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:03627be1bac4c66578de3793a7a3b9c6fda7ec2c16af0a1c52ee5ac025b132b1", size = 6882715, upload-time = "2026-04-29T00:39:36.398Z" }, + { url = "https://files.pythonhosted.org/packages/6c/d1/1ae713ca32044abaa326df048f9196f68ac897fe1f1d4349ec14ad4f8f96/fastremap-1.19.0-cp314-cp314-win32.whl", hash = "sha256:228f2fbf1df40da2a3268283fcaf3da700fe477f4c8a99e042e9235eab4013d2", size = 438590, upload-time = "2026-04-29T00:39:41.741Z" }, + { url = "https://files.pythonhosted.org/packages/bf/4c/45aaed0599d2e2eaea839c1604eb8a1d7850d122697890169360509e2618/fastremap-1.19.0-cp314-cp314-win_amd64.whl", hash = "sha256:d63c5980fbe91301d4ae37caf4e054b908b37878b68c7c8cc8cd523689576be6", size = 616956, upload-time = "2026-04-29T00:39:39.789Z" }, + { url = "https://files.pythonhosted.org/packages/d9/d7/a9251e6e279410fe3702e7bfec87b80e1559b686ff1c5a31c575483441cd/fastremap-1.19.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2cab361d27df0c3256729ef1a2047e2a0ee3d644f8bf6acf5f6d7aa01332f59a", size = 756620, upload-time = "2026-04-29T00:39:43.009Z" }, + { url = "https://files.pythonhosted.org/packages/18/8c/26dd49757f78498619be417b1a9b062acb073f62873581f766debf9e9408/fastremap-1.19.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0305002a45e57eef021c9003638134434a1fc7fabe68e1c909132b66eef6a920", size = 648660, upload-time = "2026-04-29T00:39:44.689Z" }, + { url = "https://files.pythonhosted.org/packages/cd/0a/40fb911b25b9c7bbc5c6a251d4109a686167791b4b6b794e2b4be62e144a/fastremap-1.19.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5704e0e632567a32adbee5f6ec85428983e1cac02531ae1ba283555ab7ab92ab", size = 6937623, upload-time = "2026-04-29T00:39:48.651Z" }, + { url = "https://files.pythonhosted.org/packages/39/3a/e0e07c196fab28a023888c27cdcfe7d421d44b12f24f1d782f3a40889bff/fastremap-1.19.0-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c495f7e5687a65766803b1ca8fb5468a0bcfd9b98b1585817ca91dfeb90672fc", size = 6764452, upload-time = "2026-04-29T00:39:52.621Z" }, + { url = "https://files.pythonhosted.org/packages/02/6d/311c7629d93e05b180742cb5319540fdbc506f4c8221d80cb09ff0ee9436/fastremap-1.19.0-cp314-cp314t-win32.whl", hash = "sha256:f9eddcee20abecbd96bed4c3547aaeb2a7d0692f9507e287c7001012a22ef568", size = 551561, upload-time = "2026-04-29T00:39:55.936Z" }, + { url = "https://files.pythonhosted.org/packages/09/09/8d81617b388d1be461e6e1dd318c287c3aba2c5bf3978c7075570443b2c3/fastremap-1.19.0-cp314-cp314t-win_amd64.whl", hash = "sha256:c48b6400090721f92d3ea5ff2f5c289b9d034e12722d97c5f3239c189b00f5f4", size = 770527, upload-time = "2026-04-29T00:39:54.467Z" }, ] [[package]] @@ -1734,6 +1628,20 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/31/a0/aa0383524502292aa926e2cf88ebfda47f2ea5ca71e0e599c8536274dfab/fill_voids-2.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:15d9d007f9b473115ae3df49feb5ed3f632b28ed3e39be82a34937b8c786bda1", size = 2301405, upload-time = "2026-04-30T03:16:00.191Z" }, { url = "https://files.pythonhosted.org/packages/e0/6b/3d23e65c4a967e62ca097decaa7caf182a7814102ed34f42e67c2edcee1d/fill_voids-2.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a4d9def2de9cafcec367341ce81078a30465c4de27ff55c973ee29edad07701c", size = 2360277, upload-time = "2026-04-30T03:16:01.546Z" }, { url = "https://files.pythonhosted.org/packages/ac/36/5d5d6a86d850a829dd3ea2e8036576909cc48d5ac7b26b1771625856a481/fill_voids-2.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:dc52abad93670d910d221330d11132ba9f14e9cea6df3d80772a1bbd007a9445", size = 173660, upload-time = "2026-04-30T03:16:02.957Z" }, + { url = "https://files.pythonhosted.org/packages/df/c9/1d2341811c284f396d4b2a8abf09a772a40cf456345f02bcfbaefac0701f/fill_voids-2.1.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:821f3e586df0d8202d4decc1b4751e49a980546d3ba600de9570557d1e6f3528", size = 208118, upload-time = "2026-04-30T03:16:03.91Z" }, + { url = "https://files.pythonhosted.org/packages/41/8a/564dba5148d7fea6c9241ee46cb306ef8c7fc3b73e802962d8f9456b76dd/fill_voids-2.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:72608da4556ddc09829702ab755ebfcd23ae03702303d7b757cfab102e680dc8", size = 190032, upload-time = "2026-04-30T03:16:05.392Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e4/5bd175448978d2b0742b3c2ab95e8e133088429933b25eda8a0bc5074fa4/fill_voids-2.1.2-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2d505758017fe24deb32aca0a246ef95da3838aa623f858aeeae49aff4496d38", size = 1441672, upload-time = "2026-04-30T03:16:06.842Z" }, + { url = "https://files.pythonhosted.org/packages/41/4e/152d8a8dee6858ef378bdc6b0d7fdf380dd4d71e5ebc0d0522bc40a2efad/fill_voids-2.1.2-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c5666a561eab6cd24e6bcf1fe8d9e2f31b4e0d8b7f84e26eb882d53aff033f7", size = 1450956, upload-time = "2026-04-30T03:16:08.426Z" }, + { url = "https://files.pythonhosted.org/packages/42/e0/68b56983099a5ff02f3f7994397bfe4efff849cf58f4e8886759e7dfe66d/fill_voids-2.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:78a2f22b9b221cdc0f19030a9355a73192a1e4087d2fb5acae49c8f84653d6fa", size = 2276253, upload-time = "2026-04-30T03:16:09.942Z" }, + { url = "https://files.pythonhosted.org/packages/eb/ed/818f29b56087ceda015cbd1c5b93c323b98b9f8afe1a918e46a776930887/fill_voids-2.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:14023b0803da5fc77aebf16f404596965d1699ea58a3d658da3d1564f374f4c4", size = 2344877, upload-time = "2026-04-30T03:16:11.549Z" }, + { url = "https://files.pythonhosted.org/packages/35/76/500e0803afa9c9224b5e3f2cf534fe731f36eb68090c762ef9cd004e0d16/fill_voids-2.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:56dbd5aaff3b5e07824d974525e14a116526b3c07ae4dafc5a805eab99ae016f", size = 175811, upload-time = "2026-04-30T03:16:13.16Z" }, + { url = "https://files.pythonhosted.org/packages/de/49/b6420ee8e85608ce57c56d3ee52f8ae4a9d9dc8d96fdc5b2019f0de4e8cc/fill_voids-2.1.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:a813b53253144a82548902066a251f2ae52598fb3ef44722293aba82a8367c09", size = 218370, upload-time = "2026-04-30T03:16:14.119Z" }, + { url = "https://files.pythonhosted.org/packages/c7/91/b1e107315073fd9fd72a0be4f2ae0d750f3f6789a6ae92ced8b7d44ef4b2/fill_voids-2.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:afc0f086ee0d72cf124ea2e05cd91de43e6a2dcfea2214ebe2eae25532118141", size = 202100, upload-time = "2026-04-30T03:16:15.225Z" }, + { url = "https://files.pythonhosted.org/packages/2e/15/a89d04352035896d8bee737cf3af6768a8aca5b354310b25339da336248e/fill_voids-2.1.2-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a4f86e807afce22fa0668c97ad9959d1b1ce7b255411832741e1a9410432f63", size = 1441286, upload-time = "2026-04-30T03:16:16.479Z" }, + { url = "https://files.pythonhosted.org/packages/92/02/fdcf6a3fa3e9ee070828d397b2caf80a02183d45b205f6f12febd3dc5716/fill_voids-2.1.2-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8b1095cbb7def09ad9d32d52adfebc16eb6b410ec087d341ccfd4013aa5a6ef8", size = 1413039, upload-time = "2026-04-30T03:16:18.01Z" }, + { url = "https://files.pythonhosted.org/packages/d8/e1/47747ee139e99d239b2df25dd2e1ae2bf979592d3a03670244c3f174474a/fill_voids-2.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:620455dca04628b71f02ff86dfb7056f07f93fb6022e5b90006ad80a8b1633df", size = 2257624, upload-time = "2026-04-30T03:16:19.51Z" }, + { url = "https://files.pythonhosted.org/packages/51/b8/5f62ef7ecc2531ca0e8c99b1b8a6df70e4d1960ed86520223feb9f0dc238/fill_voids-2.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:02a044ec78f630155fb4eab8bbaa6f935c915472e5d4b6ed0cbe643dd026dc73", size = 2307237, upload-time = "2026-04-30T03:16:21.094Z" }, + { url = "https://files.pythonhosted.org/packages/74/f6/1797633bcdeb9121de82d73c35ac4e1fa8ae24e3778e2324d7ed923e27ba/fill_voids-2.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:883695c30048660ef043ee8a48e5a15b0e70e5db792aa2207c9b3812472dfaf5", size = 203359, upload-time = "2026-04-30T03:16:22.489Z" }, ] [[package]] @@ -1744,30 +1652,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e8/2d/d2a548598be01649e2d46231d151a6c56d10b964d94043a335ae56ea2d92/flatbuffers-25.12.19-py2.py3-none-any.whl", hash = "sha256:7634f50c427838bb021c2d66a3d1168e9d199b0607e6329399f04846d42e20b4", size = 26661, upload-time = "2025-12-19T23:16:13.622Z" }, ] -[[package]] -name = "flexcache" -version = "0.3" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/55/b0/8a21e330561c65653d010ef112bf38f60890051d244ede197ddaa08e50c1/flexcache-0.3.tar.gz", hash = "sha256:18743bd5a0621bfe2cf8d519e4c3bfdf57a269c15d1ced3fb4b64e0ff4600656", size = 15816, upload-time = "2024-03-09T03:21:07.555Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/27/cd/c883e1a7c447479d6e13985565080e3fea88ab5a107c21684c813dba1875/flexcache-0.3-py3-none-any.whl", hash = "sha256:d43c9fea82336af6e0115e308d9d33a185390b8346a017564611f1466dcd2e32", size = 13263, upload-time = "2024-03-09T03:21:05.635Z" }, -] - -[[package]] -name = "flexparser" -version = "0.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/82/99/b4de7e39e8eaf8207ba1a8fa2241dd98b2ba72ae6e16960d8351736d8702/flexparser-0.4.tar.gz", hash = "sha256:266d98905595be2ccc5da964fe0a2c3526fbbffdc45b65b3146d75db992ef6b2", size = 31799, upload-time = "2024-11-07T02:00:56.249Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/fe/5e/3be305568fe5f34448807976dc82fc151d76c3e0e03958f34770286278c1/flexparser-0.4-py3-none-any.whl", hash = "sha256:3738b456192dcb3e15620f324c447721023c0293f6af9955b481e91d00179846", size = 27625, upload-time = "2024-11-07T02:00:54.523Z" }, -] - [[package]] name = "fonttools" version = "4.63.0" @@ -1790,6 +1674,22 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/7e/48/cc4b66d9058c0d0982c833fad10127c4b0e9324606aafa41382295ca4102/fonttools-4.63.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9ced0bd02ac751dd6319b0da88aaef24414e3b0dbc32bb4f24944821a3741a27", size = 5105892, upload-time = "2026-05-14T12:03:43.525Z" }, { url = "https://files.pythonhosted.org/packages/d8/1f/a98a30a814b9ddef3a2e706025f90b9e0bc94890e6cb15254bc86547d11a/fonttools-4.63.0-cp313-cp313-win32.whl", hash = "sha256:85be818f5506e8a7753153def2c9550178f0ecae6a47b5e0e8dbb23f7cc90380", size = 2291313, upload-time = "2026-05-14T12:03:45.594Z" }, { url = "https://files.pythonhosted.org/packages/92/46/5177b01f3b4abfdd4409f31cca4ab279c9343a26efbe9ec78c97fc612e02/fonttools-4.63.0-cp313-cp313-win_amd64.whl", hash = "sha256:ba04cb5891d4c0c21b6da95eda8d7b090021508a294fff33464fc7d241e0856b", size = 2342299, upload-time = "2026-05-14T12:03:47.414Z" }, + { url = "https://files.pythonhosted.org/packages/27/d2/23d25e3f247b328be58d04a4c9f894178a0d1eda7d42867cfb388adaf416/fonttools-4.63.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fd1e3094f42d806d3d7c79162fc59e5910fcbe3a7360c385b8da969bc4493745", size = 2875338, upload-time = "2026-05-14T12:03:50.052Z" }, + { url = "https://files.pythonhosted.org/packages/cd/58/7dfa0c761cb3b2964e2a84c4dc986c926a87de0cb9fb60d5b28ded3f2914/fonttools-4.63.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:6e528da43bc3791085f8cb6141b1d13e459226790240340fcbb4625649238b03", size = 2422661, upload-time = "2026-05-14T12:03:52.154Z" }, + { url = "https://files.pythonhosted.org/packages/dd/87/64cfa18a7a1621d17b7f4502b2b0ed8a135a90c3db51ea590ee99043e76b/fonttools-4.63.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b2248c5decb223562f7902ff6325077a073f608ee8e33e88ad88db734eb9f49", size = 5010526, upload-time = "2026-05-14T12:03:54.647Z" }, + { url = "https://files.pythonhosted.org/packages/36/e1/a8933a72c45a87177fbde2696e0d0755c8c9062f8c077a961c6215fa27b1/fonttools-4.63.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:308f957cdeaf8abe4e5f2f124902ef405448af92c90f80e302a3b771c2e6116b", size = 4923946, upload-time = "2026-05-14T12:03:56.984Z" }, + { url = "https://files.pythonhosted.org/packages/27/60/872e6e233b8c5e8b41413796ff18b7fe479661bd40147e071b450dfad7a1/fonttools-4.63.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bf00f21eb5fb721dbaf73d1e9da6d02a1af7768f2ebcf9798be98beab8ba90f6", size = 4962489, upload-time = "2026-05-14T12:03:59.443Z" }, + { url = "https://files.pythonhosted.org/packages/30/c4/83c24f2ec38b90cfda84bf4b1a1f49df80e84a1db4e7ac6e0d41bf23bc39/fonttools-4.63.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c1aaa4b9c75798400ac043ce04d74e7830376c85095a5a6ed7cba2f17a266bf4", size = 5071870, upload-time = "2026-05-14T12:04:02.122Z" }, + { url = "https://files.pythonhosted.org/packages/de/40/3ae22b60ff1d41ce0bd044b31238cdc72cef99f28b976f1e128ebd618c9b/fonttools-4.63.0-cp314-cp314-win32.whl", hash = "sha256:22693918177bd9ceabec4736d338045f357769416fc6b0b2508eefef75b08616", size = 2295026, upload-time = "2026-05-14T12:04:04.47Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d4/98078064ccc76b45cb0f6c002452011e93c4bd26f6850344f0951cc1fe89/fonttools-4.63.0-cp314-cp314-win_amd64.whl", hash = "sha256:7d782fac32985914c351556f68ac0855391572bcd87de50e05970d3cd4c96fc5", size = 2347454, upload-time = "2026-05-14T12:04:06.752Z" }, + { url = "https://files.pythonhosted.org/packages/49/4e/652d1580c5f4e39f7d103b0c793e4773129ad633dce4addd0cf4dfebde02/fonttools-4.63.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:6db5140a60a5d731d21ec076745b40a310607731b0a565b50776393188649001", size = 2958152, upload-time = "2026-05-14T12:04:08.706Z" }, + { url = "https://files.pythonhosted.org/packages/0e/55/ad864c9a9b219f552eb46b32cd7906c466e5a578ba0c3abfcc0fe7413eb6/fonttools-4.63.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7d76edbff9014094dbf03bd2d074709dfa6ec7aba13d838c937a2b33d2d6a86e", size = 2460809, upload-time = "2026-05-14T12:04:10.783Z" }, + { url = "https://files.pythonhosted.org/packages/ea/2b/0aa8db70f18cf52e49b4ed5ecec68547f981160bf5ded3b5aed6faa0a6f9/fonttools-4.63.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0eac00b9118c3c2f87d272e45341871c5b3066baa3c86897fa634a7c3fb59096", size = 5148649, upload-time = "2026-05-14T12:04:12.747Z" }, + { url = "https://files.pythonhosted.org/packages/7f/63/18e4369c25043096f1048e0c9915951adc4f842bd81c6b18155824d6fa99/fonttools-4.63.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51394295f1a51de8b5f30bdb1e1b9a4231536c7064ef5c6e211eec19fa36036f", size = 4932147, upload-time = "2026-05-14T12:04:14.806Z" }, + { url = "https://files.pythonhosted.org/packages/a1/3f/67f3eac2ffd8a98446c5022f8ed3864eac878a5ff7af8df4c8286dba16cc/fonttools-4.63.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9e12f105d2b6342c559c298afb674006bb2893afc7102dcf8a1b55b0486b4e40", size = 5027237, upload-time = "2026-05-14T12:04:17.675Z" }, + { url = "https://files.pythonhosted.org/packages/1a/ba/4e6214cb38a7b04779e97bb7636de9a5c7f20af7018d03dee0b64c08510a/fonttools-4.63.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:796f27556dbe094c4824f75ca85267e4df776c79036c8441469a4df37038c196", size = 5053933, upload-time = "2026-05-14T12:04:20.818Z" }, + { url = "https://files.pythonhosted.org/packages/34/3b/214dcc19ee31d3d38fb5ad2755c11ef0514e5dc300bbaf41c0b69f393799/fonttools-4.63.0-cp314-cp314t-win32.whl", hash = "sha256:948428a275741f0b64b113c955425a953314f4b9ab9997f73a72c83e68e569c8", size = 2359326, upload-time = "2026-05-14T12:04:24.22Z" }, + { url = "https://files.pythonhosted.org/packages/dd/1e/3ff1a9b523058c2eeb6a9d50f5574e2a738200d0d94107d5bc4105e8da3f/fonttools-4.63.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6d4741eb179121cab9eea4cb2393d24492373a260d7945006358c08cfbf45419", size = 2425829, upload-time = "2026-05-14T12:04:26.829Z" }, { url = "https://files.pythonhosted.org/packages/2c/47/c99d5268f354002ce80f8d029cd9d7d872969da1de8b93d32de4dc56d6f4/fonttools-4.63.0-py3-none-any.whl", hash = "sha256:445af2eab030a16b9171ea8bdda7ebf7d96bda2df88ee182a464252f6e05e20d", size = 1164562, upload-time = "2026-05-14T12:04:29.092Z" }, ] @@ -1802,20 +1702,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014", size = 9121, upload-time = "2021-03-11T07:16:28.351Z" }, ] -[[package]] -name = "freetype-py" -version = "2.5.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d0/9c/61ba17f846b922c2d6d101cc886b0e8fb597c109cedfcb39b8c5d2304b54/freetype-py-2.5.1.zip", hash = "sha256:cfe2686a174d0dd3d71a9d8ee9bf6a2c23f5872385cf8ce9f24af83d076e2fbd", size = 851738, upload-time = "2024-08-29T18:32:26.37Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/38/a8/258dd138ebe60c79cd8cfaa6d021599208a33f0175a5e29b01f60c9ab2c7/freetype_py-2.5.1-py3-none-macosx_10_9_universal2.whl", hash = "sha256:d01ded2557694f06aa0413f3400c0c0b2b5ebcaabeef7aaf3d756be44f51e90b", size = 1747885, upload-time = "2024-08-29T18:32:17.604Z" }, - { url = "https://files.pythonhosted.org/packages/a2/93/280ad06dc944e40789b0a641492321a2792db82edda485369cbc59d14366/freetype_py-2.5.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d2f6b3d68496797da23204b3b9c4e77e67559c80390fc0dc8b3f454ae1cd819", size = 1051055, upload-time = "2024-08-29T18:32:19.153Z" }, - { url = "https://files.pythonhosted.org/packages/b6/36/853cad240ec63e21a37a512ee19c896b655ce1772d803a3dd80fccfe63fe/freetype_py-2.5.1-py3-none-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:289b443547e03a4f85302e3ac91376838e0d11636050166662a4f75e3087ed0b", size = 1043856, upload-time = "2024-08-29T18:32:20.565Z" }, - { url = "https://files.pythonhosted.org/packages/93/6f/fcc1789e42b8c6617c3112196d68e87bfe7d957d80812d3c24d639782dcb/freetype_py-2.5.1-py3-none-musllinux_1_1_aarch64.whl", hash = "sha256:cd3bfdbb7e1a84818cfbc8025fca3096f4f2afcd5d4641184bf0a3a2e6f97bbf", size = 1108180, upload-time = "2024-08-29T18:32:21.871Z" }, - { url = "https://files.pythonhosted.org/packages/2a/1b/161d3a6244b8a820aef188e4397a750d4a8196316809576d015f26594296/freetype_py-2.5.1-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:3c1aefc4f0d5b7425f014daccc5fdc7c6f914fb7d6a695cc684f1c09cd8c1660", size = 1106792, upload-time = "2024-08-29T18:32:23.134Z" }, - { url = "https://files.pythonhosted.org/packages/93/6e/bd7fbfacca077bc6f34f1a1109800a2c41ab50f4704d3a0507ba41009915/freetype_py-2.5.1-py3-none-win_amd64.whl", hash = "sha256:0b7f8e0342779f65ca13ef8bc103938366fecade23e6bb37cb671c2b8ad7f124", size = 814608, upload-time = "2024-08-29T18:32:24.648Z" }, -] - [[package]] name = "frozenlist" version = "1.8.0" @@ -1870,6 +1756,38 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" }, { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" }, { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" }, + { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" }, + { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" }, + { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" }, + { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" }, + { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" }, + { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" }, + { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" }, + { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" }, + { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" }, + { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" }, + { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" }, + { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" }, + { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" }, + { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" }, + { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" }, + { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" }, + { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" }, + { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" }, + { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" }, + { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" }, + { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" }, + { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" }, + { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" }, + { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" }, + { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" }, + { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" }, + { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" }, + { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" }, + { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" }, + { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" }, + { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" }, { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" }, ] @@ -1886,9 +1804,6 @@ wheels = [ http = [ { name = "aiohttp" }, ] -s3 = [ - { name = "s3fs" }, -] [[package]] name = "future" @@ -1984,6 +1899,11 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ce/42/b468aec74a0354b34c8cbf748db20d6e350a68a2b0912e128cabee49806c/google_crc32c-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3b9776774b24ba76831609ffbabce8cdf6fa2bd5e9df37b594221c7e333a81fa", size = 33344, upload-time = "2025-12-16T00:40:24.742Z" }, { url = "https://files.pythonhosted.org/packages/1c/e8/b33784d6fc77fb5062a8a7854e43e1e618b87d5ddf610a88025e4de6226e/google_crc32c-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:89c17d53d75562edfff86679244830599ee0a48efc216200691de8b02ab6b2b8", size = 33694, upload-time = "2025-12-16T00:40:25.505Z" }, { url = "https://files.pythonhosted.org/packages/92/b1/d3cbd4d988afb3d8e4db94ca953df429ed6db7282ed0e700d25e6c7bfc8d/google_crc32c-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:57a50a9035b75643996fbf224d6661e386c7162d1dfdab9bc4ca790947d1007f", size = 34435, upload-time = "2025-12-16T00:35:22.107Z" }, + { url = "https://files.pythonhosted.org/packages/21/88/8ecf3c2b864a490b9e7010c84fd203ec8cf3b280651106a3a74dd1b0ca72/google_crc32c-1.8.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:e6584b12cb06796d285d09e33f63309a09368b9d806a551d8036a4207ea43697", size = 31301, upload-time = "2025-12-16T00:24:48.527Z" }, + { url = "https://files.pythonhosted.org/packages/36/c6/f7ff6c11f5ca215d9f43d3629163727a272eabc356e5c9b2853df2bfe965/google_crc32c-1.8.0-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:f4b51844ef67d6cf2e9425983274da75f18b1597bb2c998e1c0a0e8d46f8f651", size = 30868, upload-time = "2025-12-16T00:48:12.163Z" }, + { url = "https://files.pythonhosted.org/packages/56/15/c25671c7aad70f8179d858c55a6ae8404902abe0cdcf32a29d581792b491/google_crc32c-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b0d1a7afc6e8e4635564ba8aa5c0548e3173e41b6384d7711a9123165f582de2", size = 33381, upload-time = "2025-12-16T00:40:26.268Z" }, + { url = "https://files.pythonhosted.org/packages/42/fa/f50f51260d7b0ef5d4898af122d8a7ec5a84e2984f676f746445f783705f/google_crc32c-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8b3f68782f3cbd1bce027e48768293072813469af6a61a86f6bb4977a4380f21", size = 33734, upload-time = "2025-12-16T00:40:27.028Z" }, + { url = "https://files.pythonhosted.org/packages/08/a5/7b059810934a09fb3ccb657e0843813c1fee1183d3bc2c8041800374aa2c/google_crc32c-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:d511b3153e7011a27ab6ee6bb3a5404a55b994dc1a7322c0b87b29606d9790e2", size = 34878, upload-time = "2025-12-16T00:35:23.142Z" }, ] [[package]] @@ -2013,9 +1933,7 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c4/37/4549f149c9797c21b32c2683c33522af22522099de128b2406672526d005/greenlet-3.5.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:fa4f98af3a528f0c3fd592a26df7f376f93329c8f4d987f6bb979057af8bf5e2", size = 286220, upload-time = "2026-05-20T13:07:28.463Z" }, { url = "https://files.pythonhosted.org/packages/38/ff/a4f436709716965eaab9f36ea7b906c8a927fbe32fb1372a2071d964f6b1/greenlet-3.5.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ffea73584b216150eab159b6d12348fb253e68757974de1e2c40d8a318ac89ed", size = 601585, upload-time = "2026-05-20T14:00:06.141Z" }, { url = "https://files.pythonhosted.org/packages/65/ad/54bc3fcee3ad368a61b19b67d88117f7a8c29727bf71fffdeda81fbd946e/greenlet-3.5.1-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1072b4f9edcc1e192d9283a66a3e68d6b84c561de33a83d7858beb9ba1effe10", size = 614215, upload-time = "2026-05-20T14:05:42.675Z" }, - { url = "https://files.pythonhosted.org/packages/7c/6c/de5b1b388cd2d9fbdfeab324863daba37d54e6e233ddbefd70b385a8c591/greenlet-3.5.1-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:89101bfd5011e069be974903cb3a4e4523845e4ece2d62dcd8d358933c0ef249", size = 620094, upload-time = "2026-05-20T14:09:09.18Z" }, { url = "https://files.pythonhosted.org/packages/40/69/b91cda0647df839483201545913514c2827ebea5e5ccdf931842763bc127/greenlet-3.5.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:add5217d68b31130f0beca584d7fef4878327d2e31642b66618a14eef312b63b", size = 611358, upload-time = "2026-05-20T13:14:26.37Z" }, - { url = "https://files.pythonhosted.org/packages/4a/43/1204baffab8a6476464795a7ccf394a3248d4f22c9f87173a15b36b6d971/greenlet-3.5.1-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:e6cd99ea59dd5d89f0c956606571d79bfe6f68c9eb7f4a4083a41a7f1587edee", size = 422782, upload-time = "2026-05-20T14:01:39.597Z" }, { url = "https://files.pythonhosted.org/packages/59/90/3cf77e080350cd02fa307bb2abf05df48f4482c240275bbd2c203ba8bb1c/greenlet-3.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a5ea42a752d47a145eae922b605cd1634665ac3d5ec1e72402d5048e8d60d207", size = 1570475, upload-time = "2026-05-20T14:02:25.29Z" }, { url = "https://files.pythonhosted.org/packages/65/2c/18cece62045e74598c3c393f70dce4a63f56222015ba29a5d4eeb04f764c/greenlet-3.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c5551170cf4f5ff5623e9af81323751979fee2c731e2287b61f73cd27257b823", size = 1635625, upload-time = "2026-05-20T13:14:34.027Z" }, { url = "https://files.pythonhosted.org/packages/30/f5/310d104ddf41eb5a70f4c268d22508dfb0c3c8e86fec152be34d0d2ed819/greenlet-3.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:3c8bb982ad117d29478ef8f5533e97df21f1e2befd17a299257b0c96d1371c0b", size = 238791, upload-time = "2026-05-20T13:10:39.018Z" }, @@ -2023,13 +1941,42 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/27/69/7f7e5372d998b81001899b1c0823c957aa413ba0f2662e65821611cc31e4/greenlet-3.5.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:51518ff74664078fc51bffcc6fc529b0df5ae58da192691cee765d45ce944a2b", size = 285060, upload-time = "2026-05-20T13:08:51.899Z" }, { url = "https://files.pythonhosted.org/packages/b1/bf/387f9b6b865fd2ae0d0be09e0004827295a01b71be76ed350dd1e28a91a4/greenlet-3.5.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ffdb3c0bb002c99cd8f298957e046c3dbf6006b5b7cdf11a4e19194624a0a0a", size = 604370, upload-time = "2026-05-20T14:00:07.492Z" }, { url = "https://files.pythonhosted.org/packages/32/f5/169ce3d4e4c67291bd18f8cbe0299c9f3e45102c7f1fb3c14780c93e4532/greenlet-3.5.1-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7715a5a2c3378ba602c3a440558261e13a820bb53a82693aacd7b7f6d964e283", size = 616987, upload-time = "2026-05-20T14:05:44.237Z" }, - { url = "https://files.pythonhosted.org/packages/19/ba/c24110c55dffa55aa6e1d98b45310da33801aeba7686ff0190fe5d46fd32/greenlet-3.5.1-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d40a890035c0058cadbdc4af7569800fd28a0e527a0fdbb7b5f9418f176846ce", size = 622911, upload-time = "2026-05-20T14:09:10.598Z" }, { url = "https://files.pythonhosted.org/packages/ee/e5/7f2e41d5273be07e77560d61ea4e56485b4d6c316d2a84518c62d1364061/greenlet-3.5.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dc71ff466927a201b08305acac451ebe1aedfcea002f62f1f2f2ac2ac1e6a135", size = 613911, upload-time = "2026-05-20T13:14:27.539Z" }, - { url = "https://files.pythonhosted.org/packages/ec/7b/d20db2e8a5ad6c038702f3179b136f93f0a3d1a21a0c0777f3e470cdf4b2/greenlet-3.5.1-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:67821bb03e4e98664490edb787ff6af501194c29bbee0f5c1dfdcf1dc3d9d436", size = 425228, upload-time = "2026-05-20T14:01:40.837Z" }, { url = "https://files.pythonhosted.org/packages/c5/a4/fbdc67579b73615a1f91615e814303cc71e06128f7baaba87be79b8fb90c/greenlet-3.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cd443683db272ebaaca03af98c0b063ab30db70ea8a31a1559f35e3f7b744ccd", size = 1570689, upload-time = "2026-05-20T14:02:27.225Z" }, { url = "https://files.pythonhosted.org/packages/e6/b4/77abbe35078be39718a46cd49caf16bceb35662f97a34101dca28aa98e47/greenlet-3.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:089fff7a6ce8d9316d1f65ebc00273a56be258c1725b32b94de90a3a979557e1", size = 1635602, upload-time = "2026-05-20T13:14:36.344Z" }, { url = "https://files.pythonhosted.org/packages/37/f7/129f27ca700845b8ee8ca88ce7f43435a1239c2eddb7677fc938822762cf/greenlet-3.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:110a1ca7b49b014b097f6078272c3f4ed31af45b254de5228b79adba879f6af9", size = 238683, upload-time = "2026-05-20T13:11:50.57Z" }, { url = "https://files.pythonhosted.org/packages/6d/5c/a485a36e87df8d8fd0632ee01511244f5156a20ed3746cc6599340326395/greenlet-3.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:f16ba1efc0715b680a18b8123d90dad887c6112ae3555b4b5c32c149540c6b4e", size = 235499, upload-time = "2026-05-20T13:12:42.028Z" }, + { url = "https://files.pythonhosted.org/packages/8a/cb/c62454606daf5640369c94d8a9dd540599b1bfc090e2d2180cb77f4038d2/greenlet-3.5.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:d8ab31c9de8651a2facdd5c5bb0011f2380dd1a7af78ce2adf4b56095294fc07", size = 285579, upload-time = "2026-05-20T13:08:56.396Z" }, + { url = "https://files.pythonhosted.org/packages/ec/71/c4270398c2eba968a6071af1dfbdcaeee6ec1c24bc8b435b8cc452700da6/greenlet-3.5.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e300185139abc337ade480c327183adf42a875ac7181bfe66d7d4efea31fbea", size = 651106, upload-time = "2026-05-20T14:00:09.448Z" }, + { url = "https://files.pythonhosted.org/packages/1a/ab/71e34b78a44ec271fb5f550c17bc46d301ddc5953890d935f270b0dcdb5a/greenlet-3.5.1-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7ffdb990dcaa0234cf9845aead5df2e3c3a8b6507d409274dd87e0d5ab05ffc2", size = 663478, upload-time = "2026-05-20T14:05:45.88Z" }, + { url = "https://files.pythonhosted.org/packages/77/96/4efd6fa5c62c85426a0c19077a586258ebc3a2a146ff2493e4312a697a22/greenlet-3.5.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2f82b3597e9d83b63408affed0b48fd0f54935edac4302237b9a837be0dae33c", size = 660800, upload-time = "2026-05-20T13:14:29.129Z" }, + { url = "https://files.pythonhosted.org/packages/7a/e0/6c71401a25cac7000261304e866a2f2cc04dc74810d40e2f118aa4799495/greenlet-3.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c0141e37414c10164e702b8fb1473304221ad98f71600850c6ef7ff4880feba0", size = 1617518, upload-time = "2026-05-20T14:02:28.662Z" }, + { url = "https://files.pythonhosted.org/packages/41/26/c5c06643e8c0af9e7bf18e16cb51d0ab7625155f0392e1c9015d66d556cd/greenlet-3.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:50ae25a67bea74ea41fb14b960bc532df73eb713417b2d61892dced82fe8d3bc", size = 1681593, upload-time = "2026-05-20T13:14:39.417Z" }, + { url = "https://files.pythonhosted.org/packages/8a/bd/e11a108317485075e68af9d23039619b86b28130c3b50d227d42edece64b/greenlet-3.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:8a17c42330e261299766b75ac1ea32caa437a9453c8f65d16a13140db378ecd3", size = 239800, upload-time = "2026-05-20T13:09:30.128Z" }, + { url = "https://files.pythonhosted.org/packages/47/f8/8e8e8417b7bf28639a5a56356ef934d0375e1d0c70a57e04d7701e870ffe/greenlet-3.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:7b5f5fae05b8ac6d176a61b60c394a8cbdc2b5b91b81793066e68745cf165e54", size = 236862, upload-time = "2026-05-20T13:09:10.498Z" }, + { url = "https://files.pythonhosted.org/packages/90/12/41bf27fde4d3605d3773ae57751eda182b8be2f5398011c041173b1d9534/greenlet-3.5.1-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:ea8da1e900d758d078810d4255d8c6aa572181896a31ec79d779eb79c3adc9ad", size = 293637, upload-time = "2026-05-20T13:12:35.529Z" }, + { url = "https://files.pythonhosted.org/packages/44/44/ba14b23e9757707050c2f397d305bbcae62e5d7cad122f8b6baec5ae4a1f/greenlet-3.5.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a19570c52a21420dcbc94e661994bc325c0b5b11304540fed514586da5dc8f2e", size = 650840, upload-time = "2026-05-20T14:00:11.079Z" }, + { url = "https://files.pythonhosted.org/packages/a8/37/5ddc2b686a6844f91abecef43411842426da2e1573f60b49ecf2547f4ae1/greenlet-3.5.1-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3d955c89b75eeca4723d7cc14135f393cd47c32e2a6cb4a8e4c6e760a26b0986", size = 656416, upload-time = "2026-05-20T14:05:47.118Z" }, + { url = "https://files.pythonhosted.org/packages/e1/f0/d17510297c35a2992712f0bf84de3779749999f7d3d63aa1f09db7c62dbe/greenlet-3.5.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:de2daaaebd1a5aa88c49045b6baf9310b3263796bd88db713edf37cf53e7bb4e", size = 654397, upload-time = "2026-05-20T13:14:30.696Z" }, + { url = "https://files.pythonhosted.org/packages/37/eb/147387705bb89092645b012586e7273cb5ed3c90ef7eaf3a69173eaf0209/greenlet-3.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3bfbd69cc349e43bf3a8ae1c85548ff0718efc887615c2db16c3833d7b0b072d", size = 1614469, upload-time = "2026-05-20T14:02:30.192Z" }, + { url = "https://files.pythonhosted.org/packages/a6/4e/37ee0da7732b7aa9896f17e15579a9df34b9fcb9dd494f0adfa749af6623/greenlet-3.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4378720dd888136c27215a0214d32a4d37c3852765d45bc37aad0623423cfd78", size = 1675115, upload-time = "2026-05-20T13:14:40.972Z" }, + { url = "https://files.pythonhosted.org/packages/57/f3/97dfcf4a6eb5077f8a672234216fb5923eb89f2cab7081cb10b2cf75b605/greenlet-3.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:45718441607f9325d948db98cbc691276059316d0358c188c246da4e1d4d23d2", size = 245246, upload-time = "2026-05-20T13:12:22.646Z" }, + { url = "https://files.pythonhosted.org/packages/5d/73/d7f72e34b582f694f4a9b248162db7b09cc458a259ba8f0c0bfa1a34ea7d/greenlet-3.5.1-cp315-cp315-macosx_11_0_universal2.whl", hash = "sha256:2baee5ca02031757ffe8cc3d69f0cc0aec7065ce362622da74f32d3bcab1c541", size = 285575, upload-time = "2026-05-20T13:12:07.043Z" }, + { url = "https://files.pythonhosted.org/packages/df/59/fa9c6e87dc8ad27a95dabe2f29f372b733d05a8a67470f6c901ed9975655/greenlet-3.5.1-cp315-cp315-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9b1ec3274918a81d3ea778b9e75b56b72b33f300edb6cf7f3a7fe1dae56683de", size = 656428, upload-time = "2026-05-20T14:00:12.556Z" }, + { url = "https://files.pythonhosted.org/packages/f6/f9/e753408871eaa61dfe35e619cfc67512b036fde99893685d50eea9e07146/greenlet-3.5.1-cp315-cp315-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:111e2390ffffc47d5840b01711dd7fac07d4c09283d0283e7f3264b14e284c64", size = 667064, upload-time = "2026-05-20T14:05:48.662Z" }, + { url = "https://files.pythonhosted.org/packages/96/27/5565b5b40389f1c7753003a07e21892fda8660926787036d5bc0308b8113/greenlet-3.5.1-cp315-cp315-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e630136e905fe5ff43e86945ae41220b6d1470956a39220e708110ac48d01ea5", size = 665697, upload-time = "2026-05-20T13:14:32.943Z" }, + { url = "https://files.pythonhosted.org/packages/cf/82/e7de4178c0c2d1c9a5a3be3cc0b33e46a85b3ee4a77c071bf7ad8600e079/greenlet-3.5.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:975eac34b44a7077ca4d421348455b94f0f518246a7f14bc6d2fdcfe5b584368", size = 1621256, upload-time = "2026-05-20T14:02:31.91Z" }, + { url = "https://files.pythonhosted.org/packages/00/10/f2dddcf7dacac17dfc68691809589adad06135eb28930429cf58a6467a2f/greenlet-3.5.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:9ab3c3a0b2ae6198e67c898dad5215a49f9ae0d0081b3c3ec59f333e39eeca26", size = 1685956, upload-time = "2026-05-20T13:14:42.55Z" }, + { url = "https://files.pythonhosted.org/packages/22/17/4a232b32133230ada52f70e9d7f5b65b0caef8772f01849bd8d149e7e4ca/greenlet-3.5.1-cp315-cp315-win_amd64.whl", hash = "sha256:cbfc69be86e10dcfef5b1e6269d1d6926552aa89ee39e1de3353360c1b6989ab", size = 239802, upload-time = "2026-05-20T13:13:15.481Z" }, + { url = "https://files.pythonhosted.org/packages/c2/ae/4e623a7e6d4d2a5f4cb8e4c82de4169fc637942caae68d6e676b8a128ac5/greenlet-3.5.1-cp315-cp315-win_arm64.whl", hash = "sha256:92fd6d44ac5e5a887c8a5dc4a8ba0ba908527c31c12f78c6bc7dcfe8aab279f6", size = 236853, upload-time = "2026-05-20T13:15:37.301Z" }, + { url = "https://files.pythonhosted.org/packages/7a/57/816d9cff29119da3505b3d6a5e14a8af89006ac36f47f891ff293ee05af1/greenlet-3.5.1-cp315-cp315t-macosx_11_0_universal2.whl", hash = "sha256:a6fdf2433a5441ef9a95464f7c3e674775da1c8c1177fff311cee1acad4626ed", size = 293877, upload-time = "2026-05-20T13:10:19.078Z" }, + { url = "https://files.pythonhosted.org/packages/23/a1/59b0a7c7d140ff1a75626680b9a9899b79a9176cab298b394968fb023295/greenlet-3.5.1-cp315-cp315t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7546556f0d649f99f6a361098a55f761181bb2ea12ff150bb16d26092ad88244", size = 655333, upload-time = "2026-05-20T14:00:14.758Z" }, + { url = "https://files.pythonhosted.org/packages/72/1b/5efe127597625042218939d01855109f352779050768b670b52edcc16a6c/greenlet-3.5.1-cp315-cp315t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d5ee3ea898009fa898f85f9982255d35278c477bebe185beca249cab42d4526c", size = 659443, upload-time = "2026-05-20T14:05:50.159Z" }, + { url = "https://files.pythonhosted.org/packages/6c/6d/c404246ea4d22d097a7426d0efb5b781bd7eb67715f09e79001bd552ab18/greenlet-3.5.1-cp315-cp315t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a5c81f74d204d3edd136ebfd50dce53acbb776995d721a0fe801626cfc93b8cd", size = 658356, upload-time = "2026-05-20T13:14:35.091Z" }, + { url = "https://files.pythonhosted.org/packages/51/02/f8ee37fb6d2219329f350af241c27fcf12df57e723d11f6fc6d3bacdadaa/greenlet-3.5.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:2c18ef16bf6d4dd410e4dd52996888ea1497be26892fe5bbc73580aba4287b8e", size = 1619216, upload-time = "2026-05-20T14:02:33.403Z" }, + { url = "https://files.pythonhosted.org/packages/93/c5/3dc9475ace2c7a3680da12372cddd7f1ac874eb410a1ac48d3e9dab83782/greenlet-3.5.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:17d86354f0ae6b61bf9be5148d0dd34e06c3cb7c602c671f79f29ac3b150e659", size = 1678427, upload-time = "2026-05-20T13:14:43.71Z" }, + { url = "https://files.pythonhosted.org/packages/df/4e/750c15c317a41ffb36f0bf40b933e3d744a7dede61889f74443ea69690cf/greenlet-3.5.1-cp315-cp315t-win_amd64.whl", hash = "sha256:e7516cf6ae6b8a582c2770a0caed47b8a48373ed732c33d69a72913ae6ac923e", size = 245225, upload-time = "2026-05-20T13:13:59.366Z" }, + { url = "https://files.pythonhosted.org/packages/4f/fd/d3baea2eeb7b617efd47e87ca06e2ec2c6118d303aa9e918e0ce16eadc10/greenlet-3.5.1-cp315-cp315t-win_arm64.whl", hash = "sha256:5028648bf2253ec4745add746129d3904121fa7fe871a76bed23c5720573ce0a", size = 239590, upload-time = "2026-05-20T13:13:37.382Z" }, ] [[package]] @@ -2070,6 +2017,16 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/75/34/0f8202c6809a46c2b4d69125ef3667c40b1c211f8e19930e5fa1f1197039/grpcio-1.81.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0fba53cb96004b2b7fb758b46b2288cb49d0b658316a4e73f3ef67230616ee65", size = 7844481, upload-time = "2026-06-01T05:55:44.849Z" }, { url = "https://files.pythonhosted.org/packages/c0/95/c3366b5b5edf4c4adc90f2e29ca16e57965a8e56dc8d2ee89565ba1905bb/grpcio-1.81.0-cp313-cp313-win32.whl", hash = "sha256:c197e2ef75a442528072b29e9755da299110e8610e8bcbb59a6b4cf55384f005", size = 4182777, upload-time = "2026-06-01T05:55:47.459Z" }, { url = "https://files.pythonhosted.org/packages/a9/a7/932f2f748511a32e641a2aba0d30dded3ed6e8bc330e0924e4d5d86853e6/grpcio-1.81.0-cp313-cp313-win_amd64.whl", hash = "sha256:194eddfacc84d80f50512e9fd4ee851d5f2499f18f299c95aa8fb4748f0537e0", size = 4928085, upload-time = "2026-06-01T05:55:50.158Z" }, + { url = "https://files.pythonhosted.org/packages/c5/1d/28b231333857deb840bc3d182ae087510170ea6d68f21393aeb0fe499530/grpcio-1.81.0-cp314-cp314-linux_armv7l.whl", hash = "sha256:a9351055f52660b58f3d4890ea66188b5134399f82b11aa0c55bd4b99eff5390", size = 6055712, upload-time = "2026-06-01T05:55:52.889Z" }, + { url = "https://files.pythonhosted.org/packages/e8/b8/999c14f9dff0fc47549d2e827cba1343ddc18e1d1bf0d06d2cf628eecbd9/grpcio-1.81.0-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:300f3337b6425fd16ead9a4f9b2ac25801acb64aa5bc0b99eb69901645b2b1d2", size = 12057189, upload-time = "2026-06-01T05:55:55.952Z" }, + { url = "https://files.pythonhosted.org/packages/1e/3d/1fbde079572562af65351151d840525a13879eb7b481d35b55cd64c6127a/grpcio-1.81.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:97bbd623f7ded558fd4f7cb5a4f600c4d4de65c5dd364c83a5b14b2a10a2d3b5", size = 6608136, upload-time = "2026-06-01T05:55:59.069Z" }, + { url = "https://files.pythonhosted.org/packages/32/89/1f17cb6882abfd8e5a303a25d5d1665abef5a8c499a96198c65a651d1b85/grpcio-1.81.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:ff83d889e3ebf6341c8c7864ad8031591ad5ca61599072fc511644d1eb962d2b", size = 7307045, upload-time = "2026-06-01T05:56:02.376Z" }, + { url = "https://files.pythonhosted.org/packages/48/5a/f98e91b2e755652e637ea2144318b0229b290062199f761b445fe1fa6015/grpcio-1.81.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c4fe218c5a35e1d87a5a26544237f1fa41dfd9cbd3c856b0810a30061f8b0aaf", size = 6812794, upload-time = "2026-06-01T05:56:05.777Z" }, + { url = "https://files.pythonhosted.org/packages/0a/0c/77892d715ac41e7ec0ace2a50080ffb64e189188056f607a66fe0014d1ee/grpcio-1.81.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b8b025b6af43ee0ad4a70307025d77bcab5adde7c4597786010d802c203e9fc5", size = 7422767, upload-time = "2026-06-01T05:56:08.524Z" }, + { url = "https://files.pythonhosted.org/packages/3f/b8/aa04590c6564714d94954515f15a236e59d4b9b3ad01e615f1b706d7792d/grpcio-1.81.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:3d4e0ce5a40a998cf608c8ba60ecfe18fdf364a9aa193ae4ac3faeecd0e86757", size = 8408551, upload-time = "2026-06-01T05:56:11.283Z" }, + { url = "https://files.pythonhosted.org/packages/43/3d/4f4a3450a1973568910c6909cb74abbf2126f68aefae5976962f9f7ad50d/grpcio-1.81.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:aa948712c8e5fa40ec250870bda14bc7578e1bb832a8912d9d2a0f720518edbe", size = 7846468, upload-time = "2026-06-01T05:56:14.536Z" }, + { url = "https://files.pythonhosted.org/packages/88/f4/5827fd248221ad3b44161c23ce9b5f4ee405b04fc6da5fd402a9aa87a84a/grpcio-1.81.0-cp314-cp314-win32.whl", hash = "sha256:fbbe81314a9d92156abce8b62c09364eb8bafc0ca2a19919a45ec64b5c6cb664", size = 4264427, upload-time = "2026-06-01T05:56:17.192Z" }, + { url = "https://files.pythonhosted.org/packages/0c/e8/127dc2b246096ad50ef7c8d9b7b31d757787aeb796368bcdd4454e4204c4/grpcio-1.81.0-cp314-cp314-win_amd64.whl", hash = "sha256:b93cee313cae4e113fbb3a0ce1ea5633db6f63cfde2b2dc1d817429026b2a50b", size = 5070848, upload-time = "2026-06-01T05:56:19.735Z" }, ] [[package]] @@ -2121,15 +2078,22 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/28/c4/532123bcd9080e250696779c927f2cb906c8bf3447df98f5ceb8dcded539/h5py-3.16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7e420b539fb6023a259a1b14d4c9f6df8cf50d7268f48e161169987a57b737ff", size = 5414598, upload-time = "2026-03-06T13:48:29.49Z" }, { url = "https://files.pythonhosted.org/packages/c3/d9/a27997f84341fc0dfcdd1fe4179b6ba6c32a7aa880fdb8c514d4dad6fba3/h5py-3.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:18f2bbcd545e6991412253b98727374c356d67caa920e68dc79eab36bf5fedad", size = 3175509, upload-time = "2026-03-06T13:48:31.131Z" }, { url = "https://files.pythonhosted.org/packages/a5/23/bb8647521d4fd770c30a76cfc6cb6a2f5495868904054e92f2394c5a78ff/h5py-3.16.0-cp313-cp313-win_arm64.whl", hash = "sha256:656f00e4d903199a1d58df06b711cf3ca632b874b4207b7dbec86185b5c8c7d4", size = 2647362, upload-time = "2026-03-06T13:48:33.411Z" }, -] - -[[package]] -name = "heapdict" -version = "1.0.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/5a/9b/d8963ae7e388270b695f3b556b6dc9adb70ae9618fba09aa1e7b1886652d/HeapDict-1.0.1.tar.gz", hash = "sha256:8495f57b3e03d8e46d5f1b2cc62ca881aca392fd5cc048dc0aa2e1a6d23ecdb6", size = 4274, upload-time = "2019-09-09T18:57:02.154Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b6/9d/cd4777dbcf3bef9d9627e0fe4bc43d2e294b1baeb01d0422399d5e9de319/HeapDict-1.0.1-py3-none-any.whl", hash = "sha256:6065f90933ab1bb7e50db403b90cab653c853690c5992e69294c2de2b253fc92", size = 3917, upload-time = "2019-09-09T18:57:00.821Z" }, + { url = "https://files.pythonhosted.org/packages/48/3c/7fcd9b4c9eed82e91fb15568992561019ae7a829d1f696b2c844355d95dd/h5py-3.16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:9c9d307c0ef862d1cd5714f72ecfafe0a5d7529c44845afa8de9f46e5ba8bd65", size = 3678608, upload-time = "2026-03-06T13:48:35.183Z" }, + { url = "https://files.pythonhosted.org/packages/6a/b7/9366ed44ced9b7ef357ab48c94205280276db9d7f064aa3012a97227e966/h5py-3.16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:8c1eff849cdd53cbc73c214c30ebdb6f1bb8b64790b4b4fc36acdb5e43570210", size = 3054773, upload-time = "2026-03-06T13:48:37.139Z" }, + { url = "https://files.pythonhosted.org/packages/58/a5/4964bc0e91e86340c2bbda83420225b2f770dcf1eb8a39464871ad769436/h5py-3.16.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:e2c04d129f180019e216ee5f9c40b78a418634091c8782e1f723a6ca3658b965", size = 5198886, upload-time = "2026-03-06T13:48:38.879Z" }, + { url = "https://files.pythonhosted.org/packages/f1/16/d905e7f53e661ce2c24686c38048d8e2b750ffc4350009d41c4e6c6c9826/h5py-3.16.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:e4360f15875a532bc7b98196c7592ed4fc92672a57c0a621355961cafb17a6dd", size = 5404883, upload-time = "2026-03-06T13:48:41.324Z" }, + { url = "https://files.pythonhosted.org/packages/4b/f2/58f34cb74af46d39f4cd18ea20909a8514960c5a3e5b92fd06a28161e0a8/h5py-3.16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:3fae9197390c325e62e0a1aa977f2f62d994aa87aab182abbea85479b791197c", size = 5192039, upload-time = "2026-03-06T13:48:43.117Z" }, + { url = "https://files.pythonhosted.org/packages/ce/ca/934a39c24ce2e2db017268c08da0537c20fa0be7e1549be3e977313fc8f5/h5py-3.16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:43259303989ac8adacc9986695b31e35dba6fd1e297ff9c6a04b7da5542139cc", size = 5421526, upload-time = "2026-03-06T13:48:44.838Z" }, + { url = "https://files.pythonhosted.org/packages/3e/14/615a450205e1b56d16c6783f5ccd116cde05550faad70ae077c955654a75/h5py-3.16.0-cp314-cp314-win_amd64.whl", hash = "sha256:fa48993a0b799737ba7fd21e2350fa0a60701e58180fae9f2de834bc39a147ab", size = 3183263, upload-time = "2026-03-06T13:48:47.117Z" }, + { url = "https://files.pythonhosted.org/packages/7b/48/a6faef5ed632cae0c65ac6b214a6614a0b510c3183532c521bdb0055e117/h5py-3.16.0-cp314-cp314-win_arm64.whl", hash = "sha256:1897a771a7f40d05c262fc8f37376ec37873218544b70216872876c627640f63", size = 2663450, upload-time = "2026-03-06T13:48:48.707Z" }, + { url = "https://files.pythonhosted.org/packages/5d/32/0c8bb8aedb62c772cf7c1d427c7d1951477e8c2835f872bc0a13d1f85f86/h5py-3.16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:15922e485844f77c0b9d275396d435db3baa58292a9c2176a386e072e0cf2491", size = 3760693, upload-time = "2026-03-06T13:48:50.453Z" }, + { url = "https://files.pythonhosted.org/packages/1d/1f/fcc5977d32d6387c5c9a694afee716a5e20658ac08b3ff24fdec79fb05f2/h5py-3.16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:df02dd29bd247f98674634dfe41f89fd7c16ba3d7de8695ec958f58404a4e618", size = 3181305, upload-time = "2026-03-06T13:48:52.221Z" }, + { url = "https://files.pythonhosted.org/packages/f5/a1/af87f64b9f986889884243643621ebbd4ac72472ba8ec8cec891ac8e2ca1/h5py-3.16.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:0f456f556e4e2cebeebd9d66adf8dc321770a42593494a0b6f0af54a7567b242", size = 5074061, upload-time = "2026-03-06T13:48:54.089Z" }, + { url = "https://files.pythonhosted.org/packages/cc/d0/146f5eaff3dc246a9c7f6e5e4f42bd45cc613bce16693bcd4d1f7c958bf5/h5py-3.16.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:3e6cb3387c756de6a9492d601553dffea3fe11b5f22b443aac708c69f3f55e16", size = 5279216, upload-time = "2026-03-06T13:48:56.75Z" }, + { url = "https://files.pythonhosted.org/packages/a1/9d/12a13424f1e604fc7df9497b73c0356fb78c2fb206abd7465ce47226e8fd/h5py-3.16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8389e13a1fd745ad2856873e8187fd10268b2d9677877bb667b41aebd771d8b7", size = 5070068, upload-time = "2026-03-06T13:48:59.169Z" }, + { url = "https://files.pythonhosted.org/packages/41/8c/bbe98f813722b4873818a8db3e15aa3e625b59278566905ac439725e8070/h5py-3.16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:346df559a0f7dcb31cf8e44805319e2ab24b8957c45e7708ce503b2ec79ba725", size = 5300253, upload-time = "2026-03-06T13:49:02.033Z" }, + { url = "https://files.pythonhosted.org/packages/32/9e/87e6705b4d6890e7cecdf876e2a7d3e40654a2ae37482d79a6f1b87f7b92/h5py-3.16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4c6ab014ab704b4feaa719ae783b86522ed0bf1f82184704ed3c9e4e3228796e", size = 3381671, upload-time = "2026-03-06T13:49:04.351Z" }, + { url = "https://files.pythonhosted.org/packages/96/91/9fad90cfc5f9b2489c7c26ad897157bce82f0e9534a986a221b99760b23b/h5py-3.16.0-cp314-cp314t-win_arm64.whl", hash = "sha256:faca8fb4e4319c09d83337adc80b2ca7d5c5a343c2d6f1b6388f32cfecca13c1", size = 2740706, upload-time = "2026-03-06T13:49:06.347Z" }, ] [[package]] @@ -2146,6 +2110,14 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/13/59/c74efbbd4e8728172b2cc72a2bc014d2947a4b7bdced932fbd3f5da1a4e5/hf_xet-1.5.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2baea1b0b989e5c152fe81425f7745ddc8901280ba3d97c98d8cdece7b706c60", size = 4663995, upload-time = "2026-05-06T06:18:06.1Z" }, { url = "https://files.pythonhosted.org/packages/73/32/8e1e0410af64cda9b139d1dcebdc993a8ff9c8c7c0e2696ae356d75ccc0d/hf_xet-1.5.0-cp313-cp313t-win_amd64.whl", hash = "sha256:526345b3ed45f374f6317349df489167606736c876241ba984105afe7fd4839d", size = 3966608, upload-time = "2026-05-06T06:18:19.74Z" }, { url = "https://files.pythonhosted.org/packages/fc/34/a8febc8f4edbea8b3e21b02ebc8b628679b84ba7e45cde624a7736b51500/hf_xet-1.5.0-cp313-cp313t-win_arm64.whl", hash = "sha256:786d28e2eb8315d5035544b9d137b4a842d600c434bb91bf7d0d953cce906ad4", size = 3796946, upload-time = "2026-05-06T06:18:17.568Z" }, + { url = "https://files.pythonhosted.org/packages/2a/20/8fc8996afe5815fa1a6be8e9e5c02f24500f409d599e905800d498a4e14d/hf_xet-1.5.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:872d5601e6deea30d15865ede55d29eac6daf5a534ab417b99b6ef6b076dd96c", size = 4023495, upload-time = "2026-05-06T06:18:01.94Z" }, + { url = "https://files.pythonhosted.org/packages/32/6a/93d84463c00cecb561a7508aa6303e35ee2894294eac14245526924415fe/hf_xet-1.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:9929561f5abf4581c8ea79587881dfef6b8abb2a0d8a51915936fc2a614f4e73", size = 3792731, upload-time = "2026-05-06T06:18:00.021Z" }, + { url = "https://files.pythonhosted.org/packages/9d/5a/8ec8e0c863b382d00b3c2e2af6ded6b06371be617144a625903a6d562f4b/hf_xet-1.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f7b7bbae318e583a86fb21e5a4a175d6721d628a2874f4bd022d0e660c32a682", size = 4456738, upload-time = "2026-05-06T06:17:49.574Z" }, + { url = "https://files.pythonhosted.org/packages/c5/ca/f7effa1a67717da2bcc6b6c28f71c6ca648c77acaec4e2c32f40cbe16d85/hf_xet-1.5.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:cf7b2dc6f31a4ea754bb50f74cde482dcf5d366d184076d8530b9872787f3761", size = 4251622, upload-time = "2026-05-06T06:17:47.096Z" }, + { url = "https://files.pythonhosted.org/packages/65/f2/19247dba3e231cf77dec59ddfb878f00057635ff773d099c9b59d37812c3/hf_xet-1.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8dbcbab554c9ef158ef2c991545c3e970ddd8cc7acdcd0a78c5a41095dab4ded", size = 4445667, upload-time = "2026-05-06T06:18:11.983Z" }, + { url = "https://files.pythonhosted.org/packages/7f/64/6f116801a3bcfb6f59f5c251f48cadc47ea54026441c4a385079286a94fa/hf_xet-1.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5906bf7718d3636dc13402914736abe723492cb730f744834f5f5b67d3a12702", size = 4664619, upload-time = "2026-05-06T06:18:13.771Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e8/069542d37946ed08669b127e1496fa99e78196d71de8d41eda5e9f1b7a58/hf_xet-1.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:5f3dc2248fc01cc0a00cd392ab497f1ca373fcbc7e3f2da1f452480b384e839e", size = 3966802, upload-time = "2026-05-06T06:18:28.162Z" }, + { url = "https://files.pythonhosted.org/packages/f9/91/fc6fdec27b14d04e88c386ac0a0129732b53fa23f7c4a78f4b83a039c567/hf_xet-1.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:b285cea1b5bab46b758772716ba8d6854a1a0310fed1c249d678a8b38601e5a0", size = 3797168, upload-time = "2026-05-06T06:18:26.287Z" }, { url = "https://files.pythonhosted.org/packages/3d/fb/69ff198a82cae7eb1a69fb84d93b3a3e4816564d76817fe541ddc96874eb/hf_xet-1.5.0-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:dad0dc84e941b8ba3c860659fe1fdc35c049d47cce293f003287757e971a8f56", size = 4030814, upload-time = "2026-05-06T06:17:57.933Z" }, { url = "https://files.pythonhosted.org/packages/9b/ff/edcc2b40162bef3ff78e14ab637e5f3b89243d6aee72f5949d3bb6a5af83/hf_xet-1.5.0-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:fd6e5a9b0fdac4ed03ed45ef79254a655b1aaab514a02202617fbf643f5fdf7a", size = 3798444, upload-time = "2026-05-06T06:17:55.79Z" }, { url = "https://files.pythonhosted.org/packages/49/4d/103f76b04310e5e57656696cc184690d20c466af0bca3ca88f8c8ea5d4f3/hf_xet-1.5.0-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3531b1823a0e6d77d80f9ed15ca0e00f0d115094f8ac033d5cae88f4564cc949", size = 4465986, upload-time = "2026-05-06T06:17:44.886Z" }, @@ -2156,33 +2128,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/62/94/3b66b148778ee100dcfd69c2ca22b57b41b44d3063ceec934f209e9184ce/hf_xet-1.5.0-cp37-abi3-win_arm64.whl", hash = "sha256:b6c9df403040248c76d808d3e047d64db2d923bae593eb244c41e425cf6cd7be", size = 3806916, upload-time = "2026-05-06T06:18:21.7Z" }, ] -[[package]] -name = "higra" -version = "0.6.13" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "numpy" }, -] -wheels = [ - { url = "https://files.pythonhosted.org/packages/3a/11/ac41629d93a10a8d79faf0cec961a785536f75393396f809347d9b36bc46/higra-0.6.13-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:aa1b6318672ebb87415ba0389059243fde0453a2bfb7d38dfe5489f429a76a9c", size = 7701486, upload-time = "2026-01-16T13:02:18.194Z" }, - { url = "https://files.pythonhosted.org/packages/3e/90/fb4e440d37c4a03d3bce3522d715f87c436c9ffd6c3c861b357163cd46e7/higra-0.6.13-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fecd196c551ac736bed53cf69bb19b9052d22122a36e297872fafca86b45a26f", size = 6134378, upload-time = "2026-01-16T12:55:22.208Z" }, - { url = "https://files.pythonhosted.org/packages/82/6a/27e323fe9186c74e3e9949629d04bceba76c3b99dd67ea9b3aaef66b5f7e/higra-0.6.13-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bc560952fe9a6cec4482da3163e94592f95c93045a124176541d145c98f28a2d", size = 11591985, upload-time = "2026-01-16T12:58:54.959Z" }, - { url = "https://files.pythonhosted.org/packages/61/0e/82904a866a5e430622990cb9d344e6944fd65ab79cb310292a09e0ef7d23/higra-0.6.13-cp312-cp312-win_amd64.whl", hash = "sha256:71ecbf39621acc07b42c9468da4105946cee4016425b5f1edc82fc34ac0a2957", size = 5795626, upload-time = "2026-01-16T13:59:17.29Z" }, - { url = "https://files.pythonhosted.org/packages/c9/0f/09515a1b6fdef5235b0ab830efa0d7dac78a4b4fccd2088cd7d4eea96f24/higra-0.6.13-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:df0b605729012fb2edebb2fd7eed3810c9657d607bac2bd3cf1d6b5723962942", size = 7701704, upload-time = "2026-01-16T13:04:13.576Z" }, - { url = "https://files.pythonhosted.org/packages/ea/24/d7e691ad846106c1730924f49597c824360a58ed510440a283d0552e3a2d/higra-0.6.13-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ced8e0c40ef5d89e2a8abea60409a2e7cf67477302795a769121e67f599c9b75", size = 6134369, upload-time = "2026-01-16T13:06:04.963Z" }, - { url = "https://files.pythonhosted.org/packages/42/39/4af36b2460a080b4301fd9ca6c7fa8b97c96030a14bf1c928a2c07cd603f/higra-0.6.13-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b38257cd3f922aaaced79563543df64e732239942161231867ea9398f2e9161a", size = 11593680, upload-time = "2026-01-16T12:59:02.201Z" }, - { url = "https://files.pythonhosted.org/packages/e6/b2/d1f2e3ed0870c5bc6b127a2ab917af0dd1233700d2503c67f4173f778725/higra-0.6.13-cp313-cp313-win_amd64.whl", hash = "sha256:493235a159c82c917abc17281cf4275dcb57fb1b213b3dbfdc1f81873c64e1e2", size = 5795756, upload-time = "2026-01-16T14:24:35.841Z" }, -] - -[[package]] -name = "hsluv" -version = "5.0.4" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ac/81/af16607fa045724e515579d312577261b436f36f419e7c677e7e88fcc943/hsluv-5.0.4.tar.gz", hash = "sha256:2281f946427a882010042844a38c7bbe9e0d0aaf9d46babe46366ed6f169b72e", size = 543090, upload-time = "2023-09-11T21:46:52.022Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/96/36/5bddefea3d7adf22a64f9aa9701492f8a9fe6948223f5cf2602c22ec9be7/hsluv-5.0.4-py2.py3-none-any.whl", hash = "sha256:0138bd10038e2ee1b13eecae9a7d49d4ec8c320b1d7eb4f860832c792e3e4567", size = 5252, upload-time = "2023-09-11T21:46:50.407Z" }, -] - [[package]] name = "httpcore" version = "1.0.9" @@ -2312,15 +2257,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/2c/c6/fa760e12a2483469e2bf5058c5faff664acf66cadb4df2ad6205b016a73d/imageio_ffmpeg-0.6.0-py3-none-win_amd64.whl", hash = "sha256:02fa47c83703c37df6bfe4896aab339013f62bf02c5ebf2dce6da56af04ffc0a", size = 31246824, upload-time = "2025-01-16T21:34:28.6Z" }, ] -[[package]] -name = "imagesize" -version = "2.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6c/e6/7bf14eeb8f8b7251141944835abd42eb20a658d89084b7e1f3e5fe394090/imagesize-2.0.0.tar.gz", hash = "sha256:8e8358c4a05c304f1fccf7ff96f036e7243a189e9e42e90851993c558cfe9ee3", size = 1773045, upload-time = "2026-03-03T14:18:29.941Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/5f/53/fb7122b71361a0d121b669dcf3d31244ef75badbbb724af388948de543e2/imagesize-2.0.0-py2.py3-none-any.whl", hash = "sha256:5667c5bbb57ab3f1fa4bc366f4fbc971db3d5ed011fd2715fd8001f782718d96", size = 9441, upload-time = "2026-03-03T14:18:27.892Z" }, -] - [[package]] name = "importlib-metadata" version = "9.0.0" @@ -2342,15 +2278,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/8a/db/55a262f3606bebcae07cc14095338471ad7c0bbcaa37707e6f0ee49725b7/importlib_resources-7.1.0-py3-none-any.whl", hash = "sha256:1bd7b48b4088eddb2cd16382150bb515af0bd2c70128194392725f82ad2c96a1", size = 37232, upload-time = "2026-04-12T16:36:08.219Z" }, ] -[[package]] -name = "in-n-out" -version = "0.2.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/af/08/07edfac98a38ab0208557524cbdd94a296f565b0558417ccb2c03d14a6ea/in_n_out-0.2.1.tar.gz", hash = "sha256:43cde2b7de981d41a6d70618a2b7bd989481095922a53ead4dc75f2bbd5dffea", size = 26026, upload-time = "2024-04-22T18:56:50.418Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/3b/06/711a4d105ad3d01d3ef351a1039bb5cc517a57dbf377d7da9a0808e34c77/in_n_out-0.2.1-py3-none-any.whl", hash = "sha256:343e81edb27cf41ec946134a92964f408465abdf6a065c6c55fe96f53bc3c8b7", size = 19951, upload-time = "2024-04-22T18:56:48.572Z" }, -] - [[package]] name = "inflection" version = "0.5.1" @@ -2933,6 +2860,36 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/1b/bd/877056304626943ff0f1f44c08f584300c199b887cb3176cd7e34f1515f1/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:fc4d3f1fb9ca0ae9f97b095963bc6326f1dbfd3779d6679a1e016b9baaa153d3", size = 2597482, upload-time = "2026-03-09T13:14:34.971Z" }, { url = "https://files.pythonhosted.org/packages/75/19/c60626c47bf0f8ac5dcf72c6c98e266d714f2fbbfd50cf6dab5ede3aaa50/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f443b4825c50a51ee68585522ab4a1d1257fac65896f282b4c6763337ac9f5d2", size = 2394328, upload-time = "2026-03-09T13:14:36.816Z" }, { url = "https://files.pythonhosted.org/packages/47/84/6a6d5e5bb8273756c27b7d810d47f7ef2f1f9b9fd23c9ee9a3f8c75c9cef/kiwisolver-1.5.0-cp313-cp313t-win_arm64.whl", hash = "sha256:893ff3a711d1b515ba9da14ee090519bad4610ed1962fbe298a434e8c5f8db53", size = 68410, upload-time = "2026-03-09T13:14:38.695Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/060f45052f2a01ad5762c8fdecd6d7a752b43400dc29ff75cd47225a40fd/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8df31fe574b8b3993cc61764f40941111b25c2d9fea13d3ce24a49907cd2d615", size = 123231, upload-time = "2026-03-09T13:14:41.323Z" }, + { url = "https://files.pythonhosted.org/packages/c2/a7/78da680eadd06ff35edef6ef68a1ad273bad3e2a0936c9a885103230aece/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1d49a49ac4cbfb7c1375301cd1ec90169dfeae55ff84710d782260ce77a75a02", size = 66489, upload-time = "2026-03-09T13:14:42.534Z" }, + { url = "https://files.pythonhosted.org/packages/49/b2/97980f3ad4fae37dd7fe31626e2bf75fbf8bdf5d303950ec1fab39a12da8/kiwisolver-1.5.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0cbe94b69b819209a62cb27bdfa5dc2a8977d8de2f89dfd97ba4f53ed3af754e", size = 64063, upload-time = "2026-03-09T13:14:44.759Z" }, + { url = "https://files.pythonhosted.org/packages/e7/f9/b06c934a6aa8bc91f566bd2a214fd04c30506c2d9e2b6b171953216a65b6/kiwisolver-1.5.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:80aa065ffd378ff784822a6d7c3212f2d5f5e9c3589614b5c228b311fd3063ac", size = 1475913, upload-time = "2026-03-09T13:14:46.247Z" }, + { url = "https://files.pythonhosted.org/packages/6b/f0/f768ae564a710135630672981231320bc403cf9152b5596ec5289de0f106/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e7f886f47ab881692f278ae901039a234e4025a68e6dfab514263a0b1c4ae05", size = 1282782, upload-time = "2026-03-09T13:14:48.458Z" }, + { url = "https://files.pythonhosted.org/packages/e2/9f/1de7aad00697325f05238a5f2eafbd487fb637cc27a558b5367a5f37fb7f/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5060731cc3ed12ca3a8b57acd4aeca5bbc2f49216dd0bec1650a1acd89486bcd", size = 1300815, upload-time = "2026-03-09T13:14:50.721Z" }, + { url = "https://files.pythonhosted.org/packages/5a/c2/297f25141d2e468e0ce7f7a7b92e0cf8918143a0cbd3422c1ad627e85a06/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a4aa69609f40fce3cbc3f87b2061f042eee32f94b8f11db707b66a26461591a", size = 1347925, upload-time = "2026-03-09T13:14:52.304Z" }, + { url = "https://files.pythonhosted.org/packages/b9/d3/f4c73a02eb41520c47610207b21afa8cdd18fdbf64ffd94674ae21c4812d/kiwisolver-1.5.0-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:d168fda2dbff7b9b5f38e693182d792a938c31db4dac3a80a4888de603c99554", size = 991322, upload-time = "2026-03-09T13:14:54.637Z" }, + { url = "https://files.pythonhosted.org/packages/7b/46/d3f2efef7732fcda98d22bf4ad5d3d71d545167a852ca710a494f4c15343/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:413b820229730d358efd838ecbab79902fe97094565fdc80ddb6b0a18c18a581", size = 2232857, upload-time = "2026-03-09T13:14:56.471Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ec/2d9756bf2b6d26ae4349b8d3662fb3993f16d80c1f971c179ce862b9dbae/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5124d1ea754509b09e53738ec185584cc609aae4a3b510aaf4ed6aa047ef9303", size = 2329376, upload-time = "2026-03-09T13:14:58.072Z" }, + { url = "https://files.pythonhosted.org/packages/8f/9f/876a0a0f2260f1bde92e002b3019a5fabc35e0939c7d945e0fa66185eb20/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e4415a8db000bf49a6dd1c478bf70062eaacff0f462b92b0ba68791a905861f9", size = 1982549, upload-time = "2026-03-09T13:14:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/6c/4f/ba3624dfac23a64d54ac4179832860cb537c1b0af06024936e82ca4154a0/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d618fd27420381a4f6044faa71f46d8bfd911bd077c555f7138ed88729bfbe79", size = 2494680, upload-time = "2026-03-09T13:15:01.364Z" }, + { url = "https://files.pythonhosted.org/packages/39/b7/97716b190ab98911b20d10bf92eca469121ec483b8ce0edd314f51bc85af/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5092eb5b1172947f57d6ea7d89b2f29650414e4293c47707eb499ec07a0ac796", size = 2297905, upload-time = "2026-03-09T13:15:03.925Z" }, + { url = "https://files.pythonhosted.org/packages/a3/36/4e551e8aa55c9188bca9abb5096805edbf7431072b76e2298e34fd3a3008/kiwisolver-1.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:d76e2d8c75051d58177e762164d2e9ab92886534e3a12e795f103524f221dd8e", size = 75086, upload-time = "2026-03-09T13:15:07.775Z" }, + { url = "https://files.pythonhosted.org/packages/70/15/9b90f7df0e31a003c71649cf66ef61c3c1b862f48c81007fa2383c8bd8d7/kiwisolver-1.5.0-cp314-cp314-win_arm64.whl", hash = "sha256:fa6248cd194edff41d7ea9425ced8ca3a6f838bfb295f6f1d6e6bb694a8518df", size = 66577, upload-time = "2026-03-09T13:15:09.139Z" }, + { url = "https://files.pythonhosted.org/packages/17/01/7dc8c5443ff42b38e72731643ed7cf1ed9bf01691ae5cdca98501999ed83/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d1ffeb80b5676463d7a7d56acbe8e37a20ce725570e09549fe738e02ca6b7e1e", size = 125794, upload-time = "2026-03-09T13:15:10.525Z" }, + { url = "https://files.pythonhosted.org/packages/46/8a/b4ebe46ebaac6a303417fab10c2e165c557ddaff558f9699d302b256bc53/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:bc4d8e252f532ab46a1de9349e2d27b91fce46736a9eedaa37beaca66f574ed4", size = 67646, upload-time = "2026-03-09T13:15:12.016Z" }, + { url = "https://files.pythonhosted.org/packages/60/35/10a844afc5f19d6f567359bf4789e26661755a2f36200d5d1ed8ad0126e5/kiwisolver-1.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6783e069732715ad0c3ce96dbf21dbc2235ab0593f2baf6338101f70371f4028", size = 65511, upload-time = "2026-03-09T13:15:13.311Z" }, + { url = "https://files.pythonhosted.org/packages/f8/8a/685b297052dd041dcebce8e8787b58923b6e78acc6115a0dc9189011c44b/kiwisolver-1.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e7c4c09a490dc4d4a7f8cbee56c606a320f9dc28cf92a7157a39d1ce7676a657", size = 1584858, upload-time = "2026-03-09T13:15:15.103Z" }, + { url = "https://files.pythonhosted.org/packages/9e/80/04865e3d4638ac5bddec28908916df4a3075b8c6cc101786a96803188b96/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2a075bd7bd19c70cf67c8badfa36cf7c5d8de3c9ddb8420c51e10d9c50e94920", size = 1392539, upload-time = "2026-03-09T13:15:16.661Z" }, + { url = "https://files.pythonhosted.org/packages/ba/01/77a19cacc0893fa13fafa46d1bba06fb4dc2360b3292baf4b56d8e067b24/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bdd3e53429ff02aa319ba59dfe4ceeec345bf46cf180ec2cf6fd5b942e7975e9", size = 1405310, upload-time = "2026-03-09T13:15:18.229Z" }, + { url = "https://files.pythonhosted.org/packages/53/39/bcaf5d0cca50e604cfa9b4e3ae1d64b50ca1ae5b754122396084599ef903/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cdcb35dc9d807259c981a85531048ede628eabcffb3239adf3d17463518992d", size = 1456244, upload-time = "2026-03-09T13:15:20.444Z" }, + { url = "https://files.pythonhosted.org/packages/d0/7a/72c187abc6975f6978c3e39b7cf67aeb8b3c0a8f9790aa7fd412855e9e1f/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:70d593af6a6ca332d1df73d519fddb5148edb15cd90d5f0155e3746a6d4fcc65", size = 1073154, upload-time = "2026-03-09T13:15:22.039Z" }, + { url = "https://files.pythonhosted.org/packages/c7/ca/cf5b25783ebbd59143b4371ed0c8428a278abe68d6d0104b01865b1bbd0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:377815a8616074cabbf3f53354e1d040c35815a134e01d7614b7692e4bf8acfa", size = 2334377, upload-time = "2026-03-09T13:15:23.741Z" }, + { url = "https://files.pythonhosted.org/packages/4a/e5/b1f492adc516796e88751282276745340e2a72dcd0d36cf7173e0daf3210/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0255a027391d52944eae1dbb5d4cc5903f57092f3674e8e544cdd2622826b3f0", size = 2425288, upload-time = "2026-03-09T13:15:25.789Z" }, + { url = "https://files.pythonhosted.org/packages/e6/e5/9b21fbe91a61b8f409d74a26498706e97a48008bfcd1864373d32a6ba31c/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:012b1eb16e28718fa782b5e61dc6f2da1f0792ca73bd05d54de6cb9561665fc9", size = 2063158, upload-time = "2026-03-09T13:15:27.63Z" }, + { url = "https://files.pythonhosted.org/packages/b1/02/83f47986138310f95ea95531f851b2a62227c11cbc3e690ae1374fe49f0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0e3aafb33aed7479377e5e9a82e9d4bf87063741fc99fc7ae48b0f16e32bdd6f", size = 2597260, upload-time = "2026-03-09T13:15:29.421Z" }, + { url = "https://files.pythonhosted.org/packages/07/18/43a5f24608d8c313dd189cf838c8e68d75b115567c6279de7796197cfb6a/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e7a116ae737f0000343218c4edf5bd45893bfeaff0993c0b215d7124c9f77646", size = 2394403, upload-time = "2026-03-09T13:15:31.517Z" }, + { url = "https://files.pythonhosted.org/packages/3b/b5/98222136d839b8afabcaa943b09bd05888c2d36355b7e448550211d1fca4/kiwisolver-1.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:1dd9b0b119a350976a6d781e7278ec7aca0b201e1a9e2d23d9804afecb6ca681", size = 79687, upload-time = "2026-03-09T13:15:33.204Z" }, + { url = "https://files.pythonhosted.org/packages/99/a2/ca7dc962848040befed12732dff6acae7fb3c4f6fc4272b3f6c9a30b8713/kiwisolver-1.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:58f812017cd2985c21fbffb4864d59174d4903dd66fa23815e74bbc7a0e2dd57", size = 70032, upload-time = "2026-03-09T13:15:34.411Z" }, { url = "https://files.pythonhosted.org/packages/1c/fa/2910df836372d8761bb6eff7d8bdcb1613b5c2e03f260efe7abe34d388a7/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_10_13_x86_64.whl", hash = "sha256:5ae8e62c147495b01a0f4765c878e9bfdf843412446a247e28df59936e99e797", size = 130262, upload-time = "2026-03-09T13:15:35.629Z" }, { url = "https://files.pythonhosted.org/packages/0f/41/c5f71f9f00aabcc71fee8b7475e3f64747282580c2fe748961ba29b18385/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:f6764a4ccab3078db14a632420930f6186058750df066b8ea2a7106df91d3203", size = 138036, upload-time = "2026-03-09T13:15:36.894Z" }, { url = "https://files.pythonhosted.org/packages/fa/06/7399a607f434119c6e1fdc8ec89a8d51ccccadf3341dee4ead6bd14caaf5/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c31c13da98624f957b0fb1b5bae5383b2333c2c3f6793d9825dd5ce79b525cb7", size = 194295, upload-time = "2026-03-09T13:15:38.22Z" }, @@ -2974,6 +2931,16 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f1/fb/62ab6d4b582eaf12ac991c1bdb94f2211bd7bbeb59c04108af9e9456904e/kornia_rs-0.1.14-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:603f56ffa0ffe2de50e5c3c4c606e5a37c98c0277a2ad752feac0e25920880f4", size = 3377444, upload-time = "2026-05-19T07:45:14.587Z" }, { url = "https://files.pythonhosted.org/packages/d7/a8/9f6dec9c5b78ff76dca0fd63c6f3c96b8d00e2a475fcfadd7eeee0c65729/kornia_rs-0.1.14-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:496301c800afea6867220d0f02344f44a90b50c1da22d5511c25df0c0c2b4d75", size = 3686869, upload-time = "2026-05-19T07:45:33.734Z" }, { url = "https://files.pythonhosted.org/packages/15/e7/ff8d97f922679c0f8f3aec6b27bab98c03c02feb2200543aed2e98b4b09d/kornia_rs-0.1.14-cp313-cp313t-win_amd64.whl", hash = "sha256:29cfb7b179ba0b98772bd459f6e74da67f93b290491a5c03deb9197955dfa684", size = 3359930, upload-time = "2026-05-19T07:46:20.207Z" }, + { url = "https://files.pythonhosted.org/packages/d5/49/093a3d42d52c6d5b1850f0564b82f9801575b818515a4dfbc9f82d2a7459/kornia_rs-0.1.14-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:816dd1d1713b13f3b39831d20097cb2aa69c2863c9a98555b1b32df0e5b9e309", size = 3555445, upload-time = "2026-05-19T07:46:06.481Z" }, + { url = "https://files.pythonhosted.org/packages/04/df/344d1c7e36c2cca38227b29693554c8dd1112e5b03155c5fae5fd9122df6/kornia_rs-0.1.14-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:27b23edda1f847ee4532ae2f008b16da535b947e2cb261be1865f7faff6c9fe7", size = 3349363, upload-time = "2026-05-19T07:45:52.348Z" }, + { url = "https://files.pythonhosted.org/packages/58/89/a90c7ebe73715ec5d326cf5f215f430f32fb5f208a0f7db7bc04f523d7e6/kornia_rs-0.1.14-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f1f5798b209c5e0cd6ec2629aac5b70c2b7c6c628a432a1b6a7414aca5805f9d", size = 3381572, upload-time = "2026-05-19T07:45:17.192Z" }, + { url = "https://files.pythonhosted.org/packages/ed/05/ffd6ae5b5cdddcbf9f7b7940d408c38911b8ab3911148b5b114522410ff1/kornia_rs-0.1.14-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b93a70df2ce65269de1f1e9c1fbe14e1fb2cdda6c3a39a31621b68a09cdba01d", size = 3695025, upload-time = "2026-05-19T07:45:35.916Z" }, + { url = "https://files.pythonhosted.org/packages/b0/96/56c15bd73c5ea7f242e6e03001b46db31c99fb7b287455dc36d1273f1b39/kornia_rs-0.1.14-cp314-cp314-win_amd64.whl", hash = "sha256:ff5ab2ede8eee7c05c6b55318ca96118785c40e9320e30c3fbb7f2b68b6fbe2b", size = 3366738, upload-time = "2026-05-19T07:46:21.693Z" }, + { url = "https://files.pythonhosted.org/packages/28/51/db8b3b72289a72c71a29a8d0ae683bd2f307c0b6f5d534744bdad0fd0183/kornia_rs-0.1.14-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:7726f27690cf471e8df967d71ee6c937adce764a0de0fea02aeac216b71770fc", size = 3543838, upload-time = "2026-05-19T07:46:07.958Z" }, + { url = "https://files.pythonhosted.org/packages/78/45/adc8d6642c4cda15525b50d40fae79bf80db91a12237be824cbd67059726/kornia_rs-0.1.14-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7835328d5bf1565c42ce405db125811653a207c6e5dc16e937cf4527a04d8710", size = 3341040, upload-time = "2026-05-19T07:45:53.867Z" }, + { url = "https://files.pythonhosted.org/packages/b1/62/f3855e36213a8815ae933238b68f67c7435d7f76d36a1f08da3b8a6517a3/kornia_rs-0.1.14-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4cb1a72ea7ce13a2971af16f28409c080560aa332431b3552c633197316e0869", size = 3377938, upload-time = "2026-05-19T07:45:19.273Z" }, + { url = "https://files.pythonhosted.org/packages/63/56/408f1fa7308c5ea8b3d7f5338d121580ef692f7e32858ee35f6969c158b6/kornia_rs-0.1.14-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2dc1942acd2e6cbf28f1e056518db751264550f9aaa61760ce01ede266e42b61", size = 3687771, upload-time = "2026-05-19T07:45:37.952Z" }, + { url = "https://files.pythonhosted.org/packages/22/0b/bb6d1904f92a4f1d05edb4ac39513fd7a3babc48c889bd137f09d4fd5668/kornia_rs-0.1.14-cp314-cp314t-win_amd64.whl", hash = "sha256:26b13fbf0a22c133a1957defca8460faceeb22c7ce1ab37a6f4a658944682c58", size = 3360061, upload-time = "2026-05-19T07:46:23.27Z" }, ] [[package]] @@ -3053,6 +3020,14 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/31/b8/69f5565f1a280d032525878a86511eebed0645818492feeb169dfb20ae8e/llvmlite-0.47.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2699a74321189e812d476a43d6d7f652f51811e7b5aad9d9bba842a1c7927acb", size = 56275178, upload-time = "2026-03-31T18:29:05.748Z" }, { url = "https://files.pythonhosted.org/packages/d6/da/b32cafcb926fb0ce2aa25553bf32cb8764af31438f40e2481df08884c947/llvmlite-0.47.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c6951e2b29930227963e53ee152441f0e14be92e9d4231852102d986c761e40", size = 55128632, upload-time = "2026-03-31T18:29:11.235Z" }, { url = "https://files.pythonhosted.org/packages/46/9f/4898b44e4042c60fafcb1162dfb7014f6f15b1ec19bf29cfea6bf26df90d/llvmlite-0.47.0-cp313-cp313-win_amd64.whl", hash = "sha256:c2e9adf8698d813a9a5efb2d4370caf344dbc1e145019851fee6a6f319ba760e", size = 38138695, upload-time = "2026-03-31T18:29:15.43Z" }, + { url = "https://files.pythonhosted.org/packages/1c/d4/33c8af00f0bf6f552d74f3a054f648af2c5bc6bece97972f3bfadce4f5ec/llvmlite-0.47.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:de966c626c35c9dff5ae7bf12db25637738d0df83fc370cf793bc94d43d92d14", size = 37232773, upload-time = "2026-03-31T18:29:19.453Z" }, + { url = "https://files.pythonhosted.org/packages/64/1d/a760e993e0c0ba6db38d46b9f48f6c7dceb8ac838824997fb9e25f97bc04/llvmlite-0.47.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ddbccff2aeaff8670368340a158abefc032fe9b3ccf7d9c496639263d00151aa", size = 56275176, upload-time = "2026-03-31T18:29:24.149Z" }, + { url = "https://files.pythonhosted.org/packages/84/3b/e679bc3b29127182a7f4aa2d2e9e5bea42adb93fb840484147d59c236299/llvmlite-0.47.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d4a7b778a2e144fc64468fb9bf509ac1226c9813a00b4d7afea5d988c4e22fca", size = 55128631, upload-time = "2026-03-31T18:29:29.536Z" }, + { url = "https://files.pythonhosted.org/packages/be/f7/19e2a09c62809c9e63bbd14ce71fb92c6ff7b7b3045741bb00c781efc3c9/llvmlite-0.47.0-cp314-cp314-win_amd64.whl", hash = "sha256:694e3c2cdc472ed2bd8bd4555ca002eec4310961dd58ef791d508f57b5cc4c94", size = 39153826, upload-time = "2026-03-31T18:29:33.681Z" }, + { url = "https://files.pythonhosted.org/packages/40/a1/581a8c707b5e80efdbbe1dd94527404d33fe50bceb71f39d5a7e11bd57b7/llvmlite-0.47.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:92ec8a169a20b473c1c54d4695e371bde36489fc1efa3688e11e99beba0abf9c", size = 37232772, upload-time = "2026-03-31T18:29:37.952Z" }, + { url = "https://files.pythonhosted.org/packages/11/03/16090dd6f74ba2b8b922276047f15962fbeea0a75d5601607edb301ba945/llvmlite-0.47.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fa1cbd800edd3b20bc141521f7fd45a6185a5b84109aa6855134e81397ffe72b", size = 56275178, upload-time = "2026-03-31T18:29:42.58Z" }, + { url = "https://files.pythonhosted.org/packages/f5/cb/0abf1dd4c5286a95ffe0c1d8c67aec06b515894a0dd2ac97f5e27b82ab0b/llvmlite-0.47.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f6725179b89f03b17dabe236ff3422cb8291b4c1bf40af152826dfd34e350ae8", size = 55128632, upload-time = "2026-03-31T18:29:46.939Z" }, + { url = "https://files.pythonhosted.org/packages/4f/79/d3bbab197e86e0ff4f9c07122895b66a3e0d024247fcff7f12c473cb36d9/llvmlite-0.47.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6842cf6f707ec4be3d985a385ad03f72b2d724439e118fcbe99b2929964f0453", size = 39153839, upload-time = "2026-03-31T18:29:51.004Z" }, ] [[package]] @@ -3064,22 +3039,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/db/bc/83e112abc66cd466c6b83f99118035867cecd41802f8d044638aa78a106e/locket-1.0.0-py2.py3-none-any.whl", hash = "sha256:b6c819a722f7b6bd955b80781788e4a66a55628b858d347536b7e81325a3a5e3", size = 4398, upload-time = "2022-04-20T22:04:42.23Z" }, ] -[[package]] -name = "magicgui" -version = "0.10.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "docstring-parser" }, - { name = "psygnal" }, - { name = "qtpy" }, - { name = "superqt", extra = ["iconify"] }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/ba/9c/0d918ee0a9b31f16e9b76c1b86b81b5d4b7bc491354c76030b87790f0cab/magicgui-0.10.2.tar.gz", hash = "sha256:ae7a4cbb7ef2028b827b1877cf0b06743d756074fe6ef849391d62448ab7b65d", size = 20946219, upload-time = "2026-04-10T14:45:28.927Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/56/bb/5ba264d3ccc13294e74c48c3ef0c2e96b8b13765562628515654012cc47e/magicgui-0.10.2-py3-none-any.whl", hash = "sha256:0f304d4da1a4309ad15d38cb809ef73269cea73a3195ac944f38d7c56d8e0fd5", size = 128254, upload-time = "2026-04-10T14:45:27.173Z" }, -] - [[package]] name = "markdown" version = "3.10.2" @@ -3140,6 +3099,28 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" }, { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" }, { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" }, + { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" }, + { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" }, + { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" }, + { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" }, + { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" }, + { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" }, + { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" }, + { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" }, + { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" }, + { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" }, + { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" }, + { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" }, + { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" }, + { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" }, + { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" }, + { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" }, ] [[package]] @@ -3180,6 +3161,20 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/4c/3d/ed428c971139112ef730f62770654d609467346d09d4b62617e1afd68a5a/matplotlib-3.10.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:b2b9516251cb89ff618d757daec0e2ed1bf21248013844a853d87ef85ab3081d", size = 9680790, upload-time = "2026-04-24T00:13:10.009Z" }, { url = "https://files.pythonhosted.org/packages/e7/09/052e884aaf2b985c63cb79f715f1d5b6a3eaa7de78f6a52b9dbc077d5b53/matplotlib-3.10.9-cp313-cp313t-win_amd64.whl", hash = "sha256:e9fae004b941b23ff2edcf1567a857ed77bafc8086ffa258190462328434faf8", size = 8287571, upload-time = "2026-04-24T00:13:13.087Z" }, { url = "https://files.pythonhosted.org/packages/f4/38/ae27288e788c35a4250491422f3db7750366fc8c97d6f36fbdecfc1f5518/matplotlib-3.10.9-cp313-cp313t-win_arm64.whl", hash = "sha256:6b63d9c7c769b88ab81e10dc86e4e0607cf56817b9f9e6cf24b2a5f1693b8e38", size = 8188292, upload-time = "2026-04-24T00:13:15.546Z" }, + { url = "https://files.pythonhosted.org/packages/d6/e6/3bd8afd04949f02eabc1c17115ea5255e19cacd4d06fc5abdde4eeb0052c/matplotlib-3.10.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:172db52c9e683f5d12eaf57f0f54834190e12581fe1cc2a19595a8f5acb4e77d", size = 8321276, upload-time = "2026-04-24T00:13:18.318Z" }, + { url = "https://files.pythonhosted.org/packages/41/86/86231232fff41c9f8e4a1a7d7a597d349a02527109c3af7d618366122139/matplotlib-3.10.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:97e35e8d39ccc85859095e01a53847432ba9a53ddf7986f7a54a11b73d0e143f", size = 8218218, upload-time = "2026-04-24T00:13:20.974Z" }, + { url = "https://files.pythonhosted.org/packages/85/8f/becc9722cafc64f5d2eb0b7c1bf5f585271c618a45dbd8fabeb021f898b6/matplotlib-3.10.9-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aba1615dabe83188e19d4f75a253c6a08423e04c1425e64039f800050a69de6b", size = 9608145, upload-time = "2026-04-24T00:13:23.228Z" }, + { url = "https://files.pythonhosted.org/packages/32/5d/f7e914f7d9325abff4057cee62c0fa70263683189f774473cbfb534cd13b/matplotlib-3.10.9-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34cf8167e023ad956c15f36302911d5406bd99a9862c1a8499ea6f7c0e015dc2", size = 9885085, upload-time = "2026-04-24T00:13:25.849Z" }, + { url = "https://files.pythonhosted.org/packages/a5/fd/fa69f2221534e80cc5772ac2b7d222011a2acafc2ec7216d5dd174c864ae/matplotlib-3.10.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:59476c6d29d612b8e9bb6ce8c5b631be6ba8f9e3a2421f22a02b192c7dd28716", size = 9672358, upload-time = "2026-04-24T00:13:28.906Z" }, + { url = "https://files.pythonhosted.org/packages/ab/1a/5a4f747a8b271cbb024946d2dd3c913ab5032ba430626f8c3528ada96b4b/matplotlib-3.10.9-cp314-cp314-win_amd64.whl", hash = "sha256:336b9acc64d309063126edcdaca00db9373af3c476bb94388fe9c5a53ad13e6f", size = 8349970, upload-time = "2026-04-24T00:13:31.904Z" }, + { url = "https://files.pythonhosted.org/packages/64/dc/95d60ecaefe30680a154b52ea96ab4b0dab547f1fd6aa12f5fb655e89cae/matplotlib-3.10.9-cp314-cp314-win_arm64.whl", hash = "sha256:2dc9477819ffd78ad12a20df1d9d6a6bd4fec6aaa9072681465fddca052f1456", size = 8272785, upload-time = "2026-04-24T00:13:34.511Z" }, + { url = "https://files.pythonhosted.org/packages/70/a0/005d68bc8b8418300ce6591f18586910a8526806e2ab663933d9f20a41e9/matplotlib-3.10.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:da4e09638420548f31c354032a6250e473c68e5a4e96899b4844cf39ddea23fe", size = 8367999, upload-time = "2026-04-24T00:13:36.962Z" }, + { url = "https://files.pythonhosted.org/packages/22/05/1236cc9290be70b2498af20ca348add76e3fffe7f67b477db5133a84f3ea/matplotlib-3.10.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:345f6f68ecc8da0ca56fad2ea08fde1a115eda530079eca185d50a7bc3e146c6", size = 8264543, upload-time = "2026-04-24T00:13:39.851Z" }, + { url = "https://files.pythonhosted.org/packages/cd/c2/071f5a5ff6c5bd63aaaf2f45c811d9bf2ced94bde188d9e1a519e21d0cba/matplotlib-3.10.9-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4edcfbd8565339aa62f1cd4012f7180926fdbe71850f7b0d3c379c175cd6b66c", size = 9622800, upload-time = "2026-04-24T00:13:42.296Z" }, + { url = "https://files.pythonhosted.org/packages/95/57/da7d1f10a85624b9e7db68e069dd94e58dc41dbf9463c5921632ecbe3661/matplotlib-3.10.9-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6be157fe17fc37cb95ac1d7374cf717ce9259616edec911a78d9d26dae8522d4", size = 9888561, upload-time = "2026-04-24T00:13:45.026Z" }, + { url = "https://files.pythonhosted.org/packages/67/b2/ef8d6bb59b0edb6c16c968b70f548aa13b54348972def5aa6ac85df67145/matplotlib-3.10.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4e42042d54db34fda4e95a7bd3e5789c2a995d2dad3eb8850232ee534092fbbf", size = 9680884, upload-time = "2026-04-24T00:13:48.066Z" }, + { url = "https://files.pythonhosted.org/packages/61/1c/d21bfeb9931881ebe96bcfcff27c7ae4b160ae0ec291a714c42641a56d75/matplotlib-3.10.9-cp314-cp314t-win_amd64.whl", hash = "sha256:c27df8b3848f32a83d1767566595e43cfaa4460380974da06f4279a7ec143c39", size = 8432333, upload-time = "2026-04-24T00:13:51.008Z" }, + { url = "https://files.pythonhosted.org/packages/78/23/92493c3e6e1b635ccfff146f7b99e674808787915420373ac399283764c2/matplotlib-3.10.9-cp314-cp314t-win_arm64.whl", hash = "sha256:a49f1eadc84ca85fd72fa4e89e70e61bf86452df6f971af04b12c60761a0772c", size = 8324785, upload-time = "2026-04-24T00:13:53.633Z" }, ] [[package]] @@ -3223,19 +3218,6 @@ dependencies = [ { name = "zensical" }, ] -[[package]] -name = "mip" -version = "1.17.6" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "cbcbox" }, - { name = "cffi" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/96/15/7496ce00eafc5b99e98bb696588527754d7629f11ac6208fdc9355f6eec6/mip-1.17.6.tar.gz", hash = "sha256:9da8074b80bd3ef788513d5a214ef832916d82aa66487da11a49c7da9f89d270", size = 9443716, upload-time = "2026-03-23T16:20:09.009Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/65/1d/0eb2531e779be687a3249e7f2ba5e465dd34611072390252e5fcf89e7fef/mip-1.17.6-py3-none-any.whl", hash = "sha256:4fb7ff5d7beacbe7d007de172306a76aff8fb36760fa63a5d88a8cb3aa6f4a57", size = 88214, upload-time = "2026-03-23T16:20:07.289Z" }, -] - [[package]] name = "mistune" version = "3.2.1" @@ -3352,6 +3334,16 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/40/49/0f8c498a28c0efa5f5c95a9e374c83ec1385ca41d0e85e7cf40e5d519a21/ml_dtypes-0.5.4-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531eff30e4d368cb6255bc2328d070e35836aa4f282a0fb5f3a0cd7260257298", size = 5366453, upload-time = "2025-11-17T22:32:07.115Z" }, { url = "https://files.pythonhosted.org/packages/8c/27/12607423d0a9c6bbbcc780ad19f1f6baa2b68b18ce4bddcdc122c4c68dc9/ml_dtypes-0.5.4-cp313-cp313t-win_amd64.whl", hash = "sha256:cb73dccfc991691c444acc8c0012bee8f2470da826a92e3a20bb333b1a7894e6", size = 225612, upload-time = "2025-11-17T22:32:08.615Z" }, { url = "https://files.pythonhosted.org/packages/e5/80/5a5929e92c72936d5b19872c5fb8fc09327c1da67b3b68c6a13139e77e20/ml_dtypes-0.5.4-cp313-cp313t-win_arm64.whl", hash = "sha256:3bbbe120b915090d9dd1375e4684dd17a20a2491ef25d640a908281da85e73f1", size = 164145, upload-time = "2025-11-17T22:32:09.782Z" }, + { url = "https://files.pythonhosted.org/packages/72/4e/1339dc6e2557a344f5ba5590872e80346f76f6cb2ac3dd16e4666e88818c/ml_dtypes-0.5.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:2b857d3af6ac0d39db1de7c706e69c7f9791627209c3d6dedbfca8c7e5faec22", size = 673781, upload-time = "2025-11-17T22:32:11.364Z" }, + { url = "https://files.pythonhosted.org/packages/04/f9/067b84365c7e83bda15bba2b06c6ca250ce27b20630b1128c435fb7a09aa/ml_dtypes-0.5.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:805cef3a38f4eafae3a5bf9ebdcdb741d0bcfd9e1bd90eb54abd24f928cd2465", size = 5036145, upload-time = "2025-11-17T22:32:12.783Z" }, + { url = "https://files.pythonhosted.org/packages/c6/bb/82c7dcf38070b46172a517e2334e665c5bf374a262f99a283ea454bece7c/ml_dtypes-0.5.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:14a4fd3228af936461db66faccef6e4f41c1d82fcc30e9f8d58a08916b1d811f", size = 5010230, upload-time = "2025-11-17T22:32:14.38Z" }, + { url = "https://files.pythonhosted.org/packages/e9/93/2bfed22d2498c468f6bcd0d9f56b033eaa19f33320389314c19ef6766413/ml_dtypes-0.5.4-cp314-cp314-win_amd64.whl", hash = "sha256:8c6a2dcebd6f3903e05d51960a8058d6e131fe69f952a5397e5dbabc841b6d56", size = 221032, upload-time = "2025-11-17T22:32:15.763Z" }, + { url = "https://files.pythonhosted.org/packages/76/a3/9c912fe6ea747bb10fe2f8f54d027eb265db05dfb0c6335e3e063e74e6e8/ml_dtypes-0.5.4-cp314-cp314-win_arm64.whl", hash = "sha256:5a0f68ca8fd8d16583dfa7793973feb86f2fbb56ce3966daf9c9f748f52a2049", size = 163353, upload-time = "2025-11-17T22:32:16.932Z" }, + { url = "https://files.pythonhosted.org/packages/cd/02/48aa7d84cc30ab4ee37624a2fd98c56c02326785750cd212bc0826c2f15b/ml_dtypes-0.5.4-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:bfc534409c5d4b0bf945af29e5d0ab075eae9eecbb549ff8a29280db822f34f9", size = 702085, upload-time = "2025-11-17T22:32:18.175Z" }, + { url = "https://files.pythonhosted.org/packages/5a/e7/85cb99fe80a7a5513253ec7faa88a65306be071163485e9a626fce1b6e84/ml_dtypes-0.5.4-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2314892cdc3fcf05e373d76d72aaa15fda9fb98625effa73c1d646f331fcecb7", size = 5355358, upload-time = "2025-11-17T22:32:19.7Z" }, + { url = "https://files.pythonhosted.org/packages/79/2b/a826ba18d2179a56e144aef69e57fb2ab7c464ef0b2111940ee8a3a223a2/ml_dtypes-0.5.4-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0d2ffd05a2575b1519dc928c0b93c06339eb67173ff53acb00724502cda231cf", size = 5366332, upload-time = "2025-11-17T22:32:21.193Z" }, + { url = "https://files.pythonhosted.org/packages/84/44/f4d18446eacb20ea11e82f133ea8f86e2bf2891785b67d9da8d0ab0ef525/ml_dtypes-0.5.4-cp314-cp314t-win_amd64.whl", hash = "sha256:4381fe2f2452a2d7589689693d3162e876b3ddb0a832cde7a414f8e1adf7eab1", size = 236612, upload-time = "2025-11-17T22:32:22.579Z" }, + { url = "https://files.pythonhosted.org/packages/ad/3f/3d42e9a78fe5edf792a83c074b13b9b770092a4fbf3462872f4303135f09/ml_dtypes-0.5.4-cp314-cp314t-win_arm64.whl", hash = "sha256:11942cbf2cf92157db91e5022633c0d9474d4dfd813a909383bd23ce828a4b7d", size = 168825, upload-time = "2025-11-17T22:32:23.766Z" }, ] [[package]] @@ -3400,6 +3392,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/67/32/f3cd1667028424fa7001d82e10ee35386eea1408b93d399b09fb0aa7875f/msgpack-1.1.2-cp313-cp313-win32.whl", hash = "sha256:a7787d353595c7c7e145e2331abf8b7ff1e6673a6b974ded96e6d4ec09f00c8c", size = 65037, upload-time = "2025-10-08T09:15:21.416Z" }, { url = "https://files.pythonhosted.org/packages/74/07/1ed8277f8653c40ebc65985180b007879f6a836c525b3885dcc6448ae6cb/msgpack-1.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:a465f0dceb8e13a487e54c07d04ae3ba131c7c5b95e2612596eafde1dccf64a9", size = 72631, upload-time = "2025-10-08T09:15:22.431Z" }, { url = "https://files.pythonhosted.org/packages/e5/db/0314e4e2db56ebcf450f277904ffd84a7988b9e5da8d0d61ab2d057df2b6/msgpack-1.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:e69b39f8c0aa5ec24b57737ebee40be647035158f14ed4b40e6f150077e21a84", size = 64118, upload-time = "2025-10-08T09:15:23.402Z" }, + { url = "https://files.pythonhosted.org/packages/22/71/201105712d0a2ff07b7873ed3c220292fb2ea5120603c00c4b634bcdafb3/msgpack-1.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e23ce8d5f7aa6ea6d2a2b326b4ba46c985dbb204523759984430db7114f8aa00", size = 81127, upload-time = "2025-10-08T09:15:24.408Z" }, + { url = "https://files.pythonhosted.org/packages/1b/9f/38ff9e57a2eade7bf9dfee5eae17f39fc0e998658050279cbb14d97d36d9/msgpack-1.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6c15b7d74c939ebe620dd8e559384be806204d73b4f9356320632d783d1f7939", size = 84981, upload-time = "2025-10-08T09:15:25.812Z" }, + { url = "https://files.pythonhosted.org/packages/8e/a9/3536e385167b88c2cc8f4424c49e28d49a6fc35206d4a8060f136e71f94c/msgpack-1.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99e2cb7b9031568a2a5c73aa077180f93dd2e95b4f8d3b8e14a73ae94a9e667e", size = 411885, upload-time = "2025-10-08T09:15:27.22Z" }, + { url = "https://files.pythonhosted.org/packages/2f/40/dc34d1a8d5f1e51fc64640b62b191684da52ca469da9cd74e84936ffa4a6/msgpack-1.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:180759d89a057eab503cf62eeec0aa61c4ea1200dee709f3a8e9397dbb3b6931", size = 419658, upload-time = "2025-10-08T09:15:28.4Z" }, + { url = "https://files.pythonhosted.org/packages/3b/ef/2b92e286366500a09a67e03496ee8b8ba00562797a52f3c117aa2b29514b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:04fb995247a6e83830b62f0b07bf36540c213f6eac8e851166d8d86d83cbd014", size = 403290, upload-time = "2025-10-08T09:15:29.764Z" }, + { url = "https://files.pythonhosted.org/packages/78/90/e0ea7990abea5764e4655b8177aa7c63cdfa89945b6e7641055800f6c16b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8e22ab046fa7ede9e36eeb4cfad44d46450f37bb05d5ec482b02868f451c95e2", size = 415234, upload-time = "2025-10-08T09:15:31.022Z" }, + { url = "https://files.pythonhosted.org/packages/72/4e/9390aed5db983a2310818cd7d3ec0aecad45e1f7007e0cda79c79507bb0d/msgpack-1.1.2-cp314-cp314-win32.whl", hash = "sha256:80a0ff7d4abf5fecb995fcf235d4064b9a9a8a40a3ab80999e6ac1e30b702717", size = 66391, upload-time = "2025-10-08T09:15:32.265Z" }, + { url = "https://files.pythonhosted.org/packages/6e/f1/abd09c2ae91228c5f3998dbd7f41353def9eac64253de3c8105efa2082f7/msgpack-1.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:9ade919fac6a3e7260b7f64cea89df6bec59104987cbea34d34a2fa15d74310b", size = 73787, upload-time = "2025-10-08T09:15:33.219Z" }, + { url = "https://files.pythonhosted.org/packages/6a/b0/9d9f667ab48b16ad4115c1935d94023b82b3198064cb84a123e97f7466c1/msgpack-1.1.2-cp314-cp314-win_arm64.whl", hash = "sha256:59415c6076b1e30e563eb732e23b994a61c159cec44deaf584e5cc1dd662f2af", size = 66453, upload-time = "2025-10-08T09:15:34.225Z" }, + { url = "https://files.pythonhosted.org/packages/16/67/93f80545eb1792b61a217fa7f06d5e5cb9e0055bed867f43e2b8e012e137/msgpack-1.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:897c478140877e5307760b0ea66e0932738879e7aa68144d9b78ea4c8302a84a", size = 85264, upload-time = "2025-10-08T09:15:35.61Z" }, + { url = "https://files.pythonhosted.org/packages/87/1c/33c8a24959cf193966ef11a6f6a2995a65eb066bd681fd085afd519a57ce/msgpack-1.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a668204fa43e6d02f89dbe79a30b0d67238d9ec4c5bd8a940fc3a004a47b721b", size = 89076, upload-time = "2025-10-08T09:15:36.619Z" }, + { url = "https://files.pythonhosted.org/packages/fc/6b/62e85ff7193663fbea5c0254ef32f0c77134b4059f8da89b958beb7696f3/msgpack-1.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5559d03930d3aa0f3aacb4c42c776af1a2ace2611871c84a75afe436695e6245", size = 435242, upload-time = "2025-10-08T09:15:37.647Z" }, + { url = "https://files.pythonhosted.org/packages/c1/47/5c74ecb4cc277cf09f64e913947871682ffa82b3b93c8dad68083112f412/msgpack-1.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70c5a7a9fea7f036b716191c29047374c10721c389c21e9ffafad04df8c52c90", size = 432509, upload-time = "2025-10-08T09:15:38.794Z" }, + { url = "https://files.pythonhosted.org/packages/24/a4/e98ccdb56dc4e98c929a3f150de1799831c0a800583cde9fa022fa90602d/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f2cb069d8b981abc72b41aea1c580ce92d57c673ec61af4c500153a626cb9e20", size = 415957, upload-time = "2025-10-08T09:15:40.238Z" }, + { url = "https://files.pythonhosted.org/packages/da/28/6951f7fb67bc0a4e184a6b38ab71a92d9ba58080b27a77d3e2fb0be5998f/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d62ce1f483f355f61adb5433ebfd8868c5f078d1a52d042b0a998682b4fa8c27", size = 422910, upload-time = "2025-10-08T09:15:41.505Z" }, + { url = "https://files.pythonhosted.org/packages/f0/03/42106dcded51f0a0b5284d3ce30a671e7bd3f7318d122b2ead66ad289fed/msgpack-1.1.2-cp314-cp314t-win32.whl", hash = "sha256:1d1418482b1ee984625d88aa9585db570180c286d942da463533b238b98b812b", size = 75197, upload-time = "2025-10-08T09:15:42.954Z" }, + { url = "https://files.pythonhosted.org/packages/15/86/d0071e94987f8db59d4eeb386ddc64d0bb9b10820a8d82bcd3e53eeb2da6/msgpack-1.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:5a46bf7e831d09470ad92dff02b8b1ac92175ca36b087f904a0519857c6be3ff", size = 85772, upload-time = "2025-10-08T09:15:43.954Z" }, + { url = "https://files.pythonhosted.org/packages/81/f2/08ace4142eb281c12701fc3b93a10795e4d4dc7f753911d836675050f886/msgpack-1.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d99ef64f349d5ec3293688e91486c5fdb925ed03807f64d98d205d2713c60b46", size = 70868, upload-time = "2025-10-08T09:15:44.959Z" }, ] [[package]] @@ -3462,144 +3472,52 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/dc/1d/b31650eab6c5778aceed46ba735bd97f7c7d2f54b319fa916c0f96e7805b/multidict-6.7.1-cp313-cp313t-win32.whl", hash = "sha256:df9f19c28adcb40b6aae30bbaa1478c389efd50c28d541d76760199fc1037c32", size = 47770, upload-time = "2026-01-26T02:45:06.754Z" }, { url = "https://files.pythonhosted.org/packages/ac/5b/2d2d1d522e51285bd61b1e20df8f47ae1a9d80839db0b24ea783b3832832/multidict-6.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d54ecf9f301853f2c5e802da559604b3e95bb7a3b01a9c295c6ee591b9882de8", size = 53109, upload-time = "2026-01-26T02:45:08.044Z" }, { url = "https://files.pythonhosted.org/packages/3d/a3/cc409ba012c83ca024a308516703cf339bdc4b696195644a7215a5164a24/multidict-6.7.1-cp313-cp313t-win_arm64.whl", hash = "sha256:5a37ca18e360377cfda1d62f5f382ff41f2b8c4ccb329ed974cc2e1643440118", size = 45573, upload-time = "2026-01-26T02:45:09.349Z" }, + { url = "https://files.pythonhosted.org/packages/91/cc/db74228a8be41884a567e88a62fd589a913708fcf180d029898c17a9a371/multidict-6.7.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8f333ec9c5eb1b7105e3b84b53141e66ca05a19a605368c55450b6ba208cb9ee", size = 75190, upload-time = "2026-01-26T02:45:10.651Z" }, + { url = "https://files.pythonhosted.org/packages/d5/22/492f2246bb5b534abd44804292e81eeaf835388901f0c574bac4eeec73c5/multidict-6.7.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a407f13c188f804c759fc6a9f88286a565c242a76b27626594c133b82883b5c2", size = 44486, upload-time = "2026-01-26T02:45:11.938Z" }, + { url = "https://files.pythonhosted.org/packages/f1/4f/733c48f270565d78b4544f2baddc2fb2a245e5a8640254b12c36ac7ac68e/multidict-6.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0e161ddf326db5577c3a4cc2d8648f81456e8a20d40415541587a71620d7a7d1", size = 43219, upload-time = "2026-01-26T02:45:14.346Z" }, + { url = "https://files.pythonhosted.org/packages/24/bb/2c0c2287963f4259c85e8bcbba9182ced8d7fca65c780c38e99e61629d11/multidict-6.7.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1e3a8bb24342a8201d178c3b4984c26ba81a577c80d4d525727427460a50c22d", size = 245132, upload-time = "2026-01-26T02:45:15.712Z" }, + { url = "https://files.pythonhosted.org/packages/a7/f9/44d4b3064c65079d2467888794dea218d1601898ac50222ab8a9a8094460/multidict-6.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97231140a50f5d447d3164f994b86a0bed7cd016e2682f8650d6a9158e14fd31", size = 252420, upload-time = "2026-01-26T02:45:17.293Z" }, + { url = "https://files.pythonhosted.org/packages/8b/13/78f7275e73fa17b24c9a51b0bd9d73ba64bb32d0ed51b02a746eb876abe7/multidict-6.7.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b10359683bd8806a200fd2909e7c8ca3a7b24ec1d8132e483d58e791d881048", size = 233510, upload-time = "2026-01-26T02:45:19.356Z" }, + { url = "https://files.pythonhosted.org/packages/4b/25/8167187f62ae3cbd52da7893f58cb036b47ea3fb67138787c76800158982/multidict-6.7.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:283ddac99f7ac25a4acadbf004cb5ae34480bbeb063520f70ce397b281859362", size = 264094, upload-time = "2026-01-26T02:45:20.834Z" }, + { url = "https://files.pythonhosted.org/packages/a1/e7/69a3a83b7b030cf283fb06ce074a05a02322359783424d7edf0f15fe5022/multidict-6.7.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:538cec1e18c067d0e6103aa9a74f9e832904c957adc260e61cd9d8cf0c3b3d37", size = 260786, upload-time = "2026-01-26T02:45:22.818Z" }, + { url = "https://files.pythonhosted.org/packages/fe/3b/8ec5074bcfc450fe84273713b4b0a0dd47c0249358f5d82eb8104ffe2520/multidict-6.7.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eee46ccb30ff48a1e35bb818cc90846c6be2b68240e42a78599166722cea709", size = 248483, upload-time = "2026-01-26T02:45:24.368Z" }, + { url = "https://files.pythonhosted.org/packages/48/5a/d5a99e3acbca0e29c5d9cba8f92ceb15dce78bab963b308ae692981e3a5d/multidict-6.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa263a02f4f2dd2d11a7b1bb4362aa7cb1049f84a9235d31adf63f30143469a0", size = 248403, upload-time = "2026-01-26T02:45:25.982Z" }, + { url = "https://files.pythonhosted.org/packages/35/48/e58cd31f6c7d5102f2a4bf89f96b9cf7e00b6c6f3d04ecc44417c00a5a3c/multidict-6.7.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2e1425e2f99ec5bd36c15a01b690a1a2456209c5deed58f95469ffb46039ccbb", size = 240315, upload-time = "2026-01-26T02:45:27.487Z" }, + { url = "https://files.pythonhosted.org/packages/94/33/1cd210229559cb90b6786c30676bb0c58249ff42f942765f88793b41fdce/multidict-6.7.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:497394b3239fc6f0e13a78a3e1b61296e72bf1c5f94b4c4eb80b265c37a131cd", size = 245528, upload-time = "2026-01-26T02:45:28.991Z" }, + { url = "https://files.pythonhosted.org/packages/64/f2/6e1107d226278c876c783056b7db43d800bb64c6131cec9c8dfb6903698e/multidict-6.7.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:233b398c29d3f1b9676b4b6f75c518a06fcb2ea0b925119fb2c1bc35c05e1601", size = 258784, upload-time = "2026-01-26T02:45:30.503Z" }, + { url = "https://files.pythonhosted.org/packages/4d/c1/11f664f14d525e4a1b5327a82d4de61a1db604ab34c6603bb3c2cc63ad34/multidict-6.7.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:93b1818e4a6e0930454f0f2af7dfce69307ca03cdcfb3739bf4d91241967b6c1", size = 251980, upload-time = "2026-01-26T02:45:32.603Z" }, + { url = "https://files.pythonhosted.org/packages/e1/9f/75a9ac888121d0c5bbd4ecf4eead45668b1766f6baabfb3b7f66a410e231/multidict-6.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f33dc2a3abe9249ea5d8360f969ec7f4142e7ac45ee7014d8f8d5acddf178b7b", size = 243602, upload-time = "2026-01-26T02:45:34.043Z" }, + { url = "https://files.pythonhosted.org/packages/9a/e7/50bf7b004cc8525d80dbbbedfdc7aed3e4c323810890be4413e589074032/multidict-6.7.1-cp314-cp314-win32.whl", hash = "sha256:3ab8b9d8b75aef9df299595d5388b14530839f6422333357af1339443cff777d", size = 40930, upload-time = "2026-01-26T02:45:36.278Z" }, + { url = "https://files.pythonhosted.org/packages/e0/bf/52f25716bbe93745595800f36fb17b73711f14da59ed0bb2eba141bc9f0f/multidict-6.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:5e01429a929600e7dab7b166062d9bb54a5eed752384c7384c968c2afab8f50f", size = 45074, upload-time = "2026-01-26T02:45:37.546Z" }, + { url = "https://files.pythonhosted.org/packages/97/ab/22803b03285fa3a525f48217963da3a65ae40f6a1b6f6cf2768879e208f9/multidict-6.7.1-cp314-cp314-win_arm64.whl", hash = "sha256:4885cb0e817aef5d00a2e8451d4665c1808378dc27c2705f1bf4ef8505c0d2e5", size = 42471, upload-time = "2026-01-26T02:45:38.889Z" }, + { url = "https://files.pythonhosted.org/packages/e0/6d/f9293baa6146ba9507e360ea0292b6422b016907c393e2f63fc40ab7b7b5/multidict-6.7.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0458c978acd8e6ea53c81eefaddbbee9c6c5e591f41b3f5e8e194780fe026581", size = 82401, upload-time = "2026-01-26T02:45:40.254Z" }, + { url = "https://files.pythonhosted.org/packages/7a/68/53b5494738d83558d87c3c71a486504d8373421c3e0dbb6d0db48ad42ee0/multidict-6.7.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c0abd12629b0af3cf590982c0b413b1e7395cd4ec026f30986818ab95bfaa94a", size = 48143, upload-time = "2026-01-26T02:45:41.635Z" }, + { url = "https://files.pythonhosted.org/packages/37/e8/5284c53310dcdc99ce5d66563f6e5773531a9b9fe9ec7a615e9bc306b05f/multidict-6.7.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:14525a5f61d7d0c94b368a42cff4c9a4e7ba2d52e2672a7b23d84dc86fb02b0c", size = 46507, upload-time = "2026-01-26T02:45:42.99Z" }, + { url = "https://files.pythonhosted.org/packages/e4/fc/6800d0e5b3875568b4083ecf5f310dcf91d86d52573160834fb4bfcf5e4f/multidict-6.7.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:17307b22c217b4cf05033dabefe68255a534d637c6c9b0cc8382718f87be4262", size = 239358, upload-time = "2026-01-26T02:45:44.376Z" }, + { url = "https://files.pythonhosted.org/packages/41/75/4ad0973179361cdf3a113905e6e088173198349131be2b390f9fa4da5fc6/multidict-6.7.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a7e590ff876a3eaf1c02a4dfe0724b6e69a9e9de6d8f556816f29c496046e59", size = 246884, upload-time = "2026-01-26T02:45:47.167Z" }, + { url = "https://files.pythonhosted.org/packages/c3/9c/095bb28b5da139bd41fb9a5d5caff412584f377914bd8787c2aa98717130/multidict-6.7.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5fa6a95dfee63893d80a34758cd0e0c118a30b8dcb46372bf75106c591b77889", size = 225878, upload-time = "2026-01-26T02:45:48.698Z" }, + { url = "https://files.pythonhosted.org/packages/07/d0/c0a72000243756e8f5a277b6b514fa005f2c73d481b7d9e47cd4568aa2e4/multidict-6.7.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a0543217a6a017692aa6ae5cc39adb75e587af0f3a82288b1492eb73dd6cc2a4", size = 253542, upload-time = "2026-01-26T02:45:50.164Z" }, + { url = "https://files.pythonhosted.org/packages/c0/6b/f69da15289e384ecf2a68837ec8b5ad8c33e973aa18b266f50fe55f24b8c/multidict-6.7.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f99fe611c312b3c1c0ace793f92464d8cd263cc3b26b5721950d977b006b6c4d", size = 252403, upload-time = "2026-01-26T02:45:51.779Z" }, + { url = "https://files.pythonhosted.org/packages/a2/76/b9669547afa5a1a25cd93eaca91c0da1c095b06b6d2d8ec25b713588d3a1/multidict-6.7.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9004d8386d133b7e6135679424c91b0b854d2d164af6ea3f289f8f2761064609", size = 244889, upload-time = "2026-01-26T02:45:53.27Z" }, + { url = "https://files.pythonhosted.org/packages/7e/a9/a50d2669e506dad33cfc45b5d574a205587b7b8a5f426f2fbb2e90882588/multidict-6.7.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e628ef0e6859ffd8273c69412a2465c4be4a9517d07261b33334b5ec6f3c7489", size = 241982, upload-time = "2026-01-26T02:45:54.919Z" }, + { url = "https://files.pythonhosted.org/packages/c5/bb/1609558ad8b456b4827d3c5a5b775c93b87878fd3117ed3db3423dfbce1b/multidict-6.7.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:841189848ba629c3552035a6a7f5bf3b02eb304e9fea7492ca220a8eda6b0e5c", size = 232415, upload-time = "2026-01-26T02:45:56.981Z" }, + { url = "https://files.pythonhosted.org/packages/d8/59/6f61039d2aa9261871e03ab9dc058a550d240f25859b05b67fd70f80d4b3/multidict-6.7.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce1bbd7d780bb5a0da032e095c951f7014d6b0a205f8318308140f1a6aba159e", size = 240337, upload-time = "2026-01-26T02:45:58.698Z" }, + { url = "https://files.pythonhosted.org/packages/a1/29/fdc6a43c203890dc2ae9249971ecd0c41deaedfe00d25cb6564b2edd99eb/multidict-6.7.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b26684587228afed0d50cf804cc71062cc9c1cdf55051c4c6345d372947b268c", size = 248788, upload-time = "2026-01-26T02:46:00.862Z" }, + { url = "https://files.pythonhosted.org/packages/a9/14/a153a06101323e4cf086ecee3faadba52ff71633d471f9685c42e3736163/multidict-6.7.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9f9af11306994335398293f9958071019e3ab95e9a707dc1383a35613f6abcb9", size = 242842, upload-time = "2026-01-26T02:46:02.824Z" }, + { url = "https://files.pythonhosted.org/packages/41/5f/604ae839e64a4a6efc80db94465348d3b328ee955e37acb24badbcd24d83/multidict-6.7.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b4938326284c4f1224178a560987b6cf8b4d38458b113d9b8c1db1a836e640a2", size = 240237, upload-time = "2026-01-26T02:46:05.898Z" }, + { url = "https://files.pythonhosted.org/packages/5f/60/c3a5187bf66f6fb546ff4ab8fb5a077cbdd832d7b1908d4365c7f74a1917/multidict-6.7.1-cp314-cp314t-win32.whl", hash = "sha256:98655c737850c064a65e006a3df7c997cd3b220be4ec8fe26215760b9697d4d7", size = 48008, upload-time = "2026-01-26T02:46:07.468Z" }, + { url = "https://files.pythonhosted.org/packages/0c/f7/addf1087b860ac60e6f382240f64fb99f8bfb532bb06f7c542b83c29ca61/multidict-6.7.1-cp314-cp314t-win_amd64.whl", hash = "sha256:497bde6223c212ba11d462853cfa4f0ae6ef97465033e7dc9940cdb3ab5b48e5", size = 53542, upload-time = "2026-01-26T02:46:08.809Z" }, + { url = "https://files.pythonhosted.org/packages/4c/81/4629d0aa32302ef7b2ec65c75a728cc5ff4fa410c50096174c1632e70b3e/multidict-6.7.1-cp314-cp314t-win_arm64.whl", hash = "sha256:2bbd113e0d4af5db41d5ebfe9ccaff89de2120578164f86a5d17d5a576d1e5b2", size = 44719, upload-time = "2026-01-26T02:46:11.146Z" }, { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" }, ] [[package]] -name = "nanobind" -version = "2.13.0" +name = "narwhals" +version = "2.22.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/07/e5/a6fc2f024eaef17c68b94b5f8f56098d31859a7840a11a3dd45da2d3908a/nanobind-2.13.0.tar.gz", hash = "sha256:c7b04d6a6a4cd57985571e605539399b51331ae455d7fce576a5e2fcb89b1dcf", size = 1052101, upload-time = "2026-06-18T06:03:49.491Z" } +sdist = { url = "https://files.pythonhosted.org/packages/9c/1c/c80cb7719721a44846c6301ef118434bae30a423924bfad3a47f16bdc064/narwhals-2.22.0.tar.gz", hash = "sha256:6486282bb7e4b4ab55963efbd8be1451b764cc4874b74d1fd625eba9dc60b86f", size = 417565, upload-time = "2026-06-01T13:34:36.249Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/39/8d/cec69a0a804711fd89f47fad92cd2a438a1ceaafd9dabaf3b8b403b5cbba/nanobind-2.13.0-py3-none-any.whl", hash = "sha256:9268d7201eaf5519ae61b7a83175f2af77088cb4b99dd3ce5b00550f697da7b7", size = 269387, upload-time = "2026-06-18T06:03:47.508Z" }, -] - -[[package]] -name = "napari" -version = "0.6.5" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "app-model" }, - { name = "appdirs" }, - { name = "cachey" }, - { name = "certifi" }, - { name = "dask", extra = ["array"] }, - { name = "imageio" }, - { name = "jsonschema" }, - { name = "lazy-loader" }, - { name = "magicgui" }, - { name = "napari-console" }, - { name = "napari-plugin-engine" }, - { name = "napari-svg" }, - { name = "npe2" }, - { name = "numpy" }, - { name = "numpydoc" }, - { name = "pandas" }, - { name = "pillow" }, - { name = "pint" }, - { name = "psutil" }, - { name = "psygnal" }, - { name = "pydantic" }, - { name = "pygments" }, - { name = "pyopengl" }, - { name = "pywin32", marker = "sys_platform == 'win32'" }, - { name = "pyyaml" }, - { name = "qtpy" }, - { name = "scikit-image", extra = ["data"] }, - { name = "scipy" }, - { name = "superqt" }, - { name = "tifffile" }, - { name = "toolz" }, - { name = "tqdm" }, - { name = "typing-extensions" }, - { name = "vispy" }, - { name = "wrapt" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/0f/2c/cff26b706e1982317b19d1bd57bc7809fbbc586da794c968d1b3997e1b85/napari-0.6.5.tar.gz", hash = "sha256:00663221583467f41fa956a672b0b4cd7a761e2642db41fc3c336d1c82339533", size = 3249897, upload-time = "2025-10-02T02:18:48.616Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/4a/69/1e8c5c7d487ad109206ce7f028ad02d41171641e1e95b4e45a913ee4d6b1/napari-0.6.5-py3-none-any.whl", hash = "sha256:51bc0b0fb6b6271555ad4167ce510b9453735aaad0ef947cfbc38bdd03d6a7be", size = 3536276, upload-time = "2025-10-02T02:18:46.062Z" }, -] - -[package.optional-dependencies] -pyqt5 = [ - { name = "pyqt5" }, - { name = "pyqt5-qt5", version = "5.15.2", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform == 'Windows'" }, -] - -[[package]] -name = "napari-console" -version = "0.1.3" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "ipykernel" }, - { name = "ipython" }, - { name = "qtconsole" }, - { name = "qtpy" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/41/4e/9b65e4c4e9520888fe69c6307818f4f75b0113b0fab1db67424b29bed9fe/napari_console-0.1.3.tar.gz", hash = "sha256:ba4f7e1cdca65a7924631372a5e58884e2e35a2b9092c79b98acb9c2dfe1254f", size = 20010, upload-time = "2024-12-20T13:48:58.451Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/5f/ff/1d1aad9292aeccf01f94ca150ce621737cbe7b9fabbb0bfef32b8da70e58/napari_console-0.1.3-py3-none-any.whl", hash = "sha256:29d1700b85561b8c91331821360c9cd0e989350f4a06b86239ec65bc06c7aecb", size = 9990, upload-time = "2024-12-20T13:48:54.093Z" }, -] - -[[package]] -name = "napari-geff" -source = { editable = "../../../../../home/eduardo.hirata/repos/napari-geff" } -dependencies = [ - { name = "geff" }, - { name = "magicgui" }, - { name = "numpy" }, - { name = "pandas" }, - { name = "qtpy" }, - { name = "scikit-image" }, -] - -[package.metadata] -requires-dist = [ - { name = "geff", specifier = ">=1.1.1" }, - { name = "magicgui" }, - { name = "napari", extras = ["all"], marker = "extra == 'all'" }, - { name = "napari", extras = ["qt"], marker = "extra == 'testing'" }, - { name = "numpy" }, - { name = "pandas" }, - { name = "pytest", marker = "extra == 'testing'" }, - { name = "pytest-cov", marker = "extra == 'testing'" }, - { name = "pytest-qt", marker = "extra == 'testing'" }, - { name = "qtpy" }, - { name = "scikit-image" }, - { name = "tox", marker = "extra == 'testing'" }, -] -provides-extras = ["all", "testing"] - -[[package]] -name = "napari-plugin-engine" -version = "0.2.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/94/72/c653308edaf7f7c84d82e388a1c46bc8f26c385027af58b5bf728f600b47/napari_plugin_engine-0.2.1.tar.gz", hash = "sha256:46829cf02f368c8f2f1aa8b998ec73bcf14a2c1f5c15abd94b82154d7aef510d", size = 55809, upload-time = "2026-02-10T08:31:20.385Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/06/bc/2509813cddd0e02736121e21bef54deeec7f0f89af2c6096d753ee1feb09/napari_plugin_engine-0.2.1-py3-none-any.whl", hash = "sha256:de30babe6fd9477816f037207938a2da7faeddc0e9e8663cb29f3d74235b6dc5", size = 33849, upload-time = "2026-02-10T08:31:19.037Z" }, -] - -[[package]] -name = "napari-svg" -version = "0.2.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "imageio" }, - { name = "numpy" }, - { name = "vispy" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/a7/90/802f8288d16c1513b908d644779e733461a53b6c1a2c7561f1464c9f1516/napari_svg-0.2.1.tar.gz", hash = "sha256:031f13b34b0948afbdcb11eb00728fe32ef7e4e3aa3905f923001d6871a08ad9", size = 17533, upload-time = "2025-01-14T07:26:30.657Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d0/ae/0eeb22806c4157a9199f65a93374e5ff5c4d2cc1411b5d25053bcd9e6b91/napari_svg-0.2.1-py3-none-any.whl", hash = "sha256:9eaa54fbbf9bfd5078b67b7d1edc9eccfd872dab89fd586374909fef4ed89a49", size = 16458, upload-time = "2025-01-14T07:26:29.328Z" }, -] - -[[package]] -name = "narwhals" -version = "2.22.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/9c/1c/c80cb7719721a44846c6301ef118434bae30a423924bfad3a47f16bdc064/narwhals-2.22.0.tar.gz", hash = "sha256:6486282bb7e4b4ab55963efbd8be1451b764cc4874b74d1fd625eba9dc60b86f", size = 417565, upload-time = "2026-06-01T13:34:36.249Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/1f/b6/e7cdde7b8e90d5dff25b622f95833ef26567ad184c977278b93a1cbd5717/narwhals-2.22.0-py3-none-any.whl", hash = "sha256:1421797ede01789cc1537619dbc3f36f840737240f748fdb24a60a0225fc80be", size = 453815, upload-time = "2026-06-01T13:34:34.127Z" }, + { url = "https://files.pythonhosted.org/packages/1f/b6/e7cdde7b8e90d5dff25b622f95833ef26567ad184c977278b93a1cbd5717/narwhals-2.22.0-py3-none-any.whl", hash = "sha256:1421797ede01789cc1537619dbc3f36f840737240f748fdb24a60a0225fc80be", size = 453815, upload-time = "2026-06-01T13:34:34.127Z" }, ] [[package]] @@ -3696,6 +3614,22 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ee/19/002fc1e6a4abeef8d92e9aa2e43aea4d462f6b170090f7752ea8887f4897/ndindex-1.10.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a91e1a0398120233d5c3b23ccb2d4b78e970d66136f1a7221fa9a53873c3d5c5", size = 1636436, upload-time = "2025-11-19T20:39:18.266Z" }, { url = "https://files.pythonhosted.org/packages/5f/8f/28b1ad78c787ac8fafd6e26419a80366617784b1779e3857fa687492f6bc/ndindex-1.10.1-cp313-cp313t-win32.whl", hash = "sha256:78bfe25941d2dac406391ddd9baf0b0fce163807b98ecc2c47a3030ee8466319", size = 158780, upload-time = "2025-11-19T20:39:20.454Z" }, { url = "https://files.pythonhosted.org/packages/d0/56/b81060607a19865bb8be8d705b1b3e8aefb8747c0fbd383e38b4cae4bd71/ndindex-1.10.1-cp313-cp313t-win_amd64.whl", hash = "sha256:08bfdc1f7a0b408d15b3ce61d141ebbebdb47a25341967e425e104c5bd512a5c", size = 167485, upload-time = "2025-11-19T20:39:21.733Z" }, + { url = "https://files.pythonhosted.org/packages/da/9b/aac1131e9f3a5635ba7b0312c3bfa610511ab4108f85c0d914a32887aa00/ndindex-1.10.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:9b5297f207ebc068c7cdf9e3cd7b95aa5c9ec04295d0a7e56b529f66787d4685", size = 176478, upload-time = "2025-11-19T20:39:23.747Z" }, + { url = "https://files.pythonhosted.org/packages/1a/05/a0d8ca0432c84550bc17af6d6479a803936895b8b8403a1216c5a55475fb/ndindex-1.10.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c5e9762452b163e33cfb6e821f86e45ba0b53bdfcd23ab5d57b48a8f566898cb", size = 175480, upload-time = "2025-11-19T20:39:25.365Z" }, + { url = "https://files.pythonhosted.org/packages/09/4a/028ab78a9f29fd2a7e86a90337cde4658eaa77b425c63045d83a1d2e4f26/ndindex-1.10.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cf80241b40adffdc3276b2c9fb63a96c6c98b4a9d941892738de8add65083962", size = 528125, upload-time = "2025-11-19T20:39:26.798Z" }, + { url = "https://files.pythonhosted.org/packages/00/a9/bd823b345fb06c83ade6ef1c1933521d4357cd04490e684d4fa30126926c/ndindex-1.10.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cf5855881884b8467dfcf45764ccf2e4279075be14b155b89c96994bb08d2e6f", size = 527328, upload-time = "2025-11-19T20:39:28.292Z" }, + { url = "https://files.pythonhosted.org/packages/91/4f/40b9c15588cbf9dde43c4fb88a31dd1f636a913fa29649f18f8e3ebca36a/ndindex-1.10.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e81a9bd36fe054b6c9fcc53d26bc9a28cf15d1ab52a0f5b854f894116f3a54e1", size = 1497508, upload-time = "2025-11-19T20:39:30.735Z" }, + { url = "https://files.pythonhosted.org/packages/24/8f/b8048f7837d2e9dff0af507b398307fa84a2aa9ea3db71b4aa800b21da4a/ndindex-1.10.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:588e8875d836a93b3cd9af482c8074bb02288ae1aff92cf277e1f02d9ae0f992", size = 1552625, upload-time = "2025-11-19T20:39:32.404Z" }, + { url = "https://files.pythonhosted.org/packages/20/aa/0ecb53c7e690a44769f2f92a843723ccb1d0ce080d93ba1ea811304cca12/ndindex-1.10.1-cp314-cp314-win32.whl", hash = "sha256:28741daca5926adff402247cd406f453ed5bb6042e82d6855938f805190e5ce9", size = 151237, upload-time = "2025-11-19T20:39:34.847Z" }, + { url = "https://files.pythonhosted.org/packages/8c/4e/197982fa8b4e6e6b9d15c38505c41076d1c552921f09f4d35acbbbbc0b70/ndindex-1.10.1-cp314-cp314-win_amd64.whl", hash = "sha256:59a3222befc0f7cdc85fb9b90a567ae890f70a864bdeb660517e9ebcb36bf1bc", size = 158925, upload-time = "2025-11-19T20:39:37.149Z" }, + { url = "https://files.pythonhosted.org/packages/24/ad/116b6154046a69fc04e2d4490905801d3839a3f21290c0b4d49b1044e251/ndindex-1.10.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:967b87b88dadb62555ec1039695c347254eccb8ca3d124c0e5dbe084c525fa93", size = 181724, upload-time = "2025-11-19T20:39:38.635Z" }, + { url = "https://files.pythonhosted.org/packages/c4/00/3ce4351366c890bcc87a5e9f1f90102547962eef356ac7c799bfdd0dddce/ndindex-1.10.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c67dde588c0fb89d872931a4ed5f9b4d21c1c70a3d92fdf0812a1de154239816", size = 181653, upload-time = "2025-11-19T20:39:40.048Z" }, + { url = "https://files.pythonhosted.org/packages/4d/05/a6fda696a2f02a3f8dd2ee9d816cb2edff6423bf0110a4876cc3b1259732/ndindex-1.10.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c65ca639a7abf72d79f22424f4abd18dece1f289a2b7b028a0ca455edd2168d4", size = 630898, upload-time = "2025-11-19T20:39:41.495Z" }, + { url = "https://files.pythonhosted.org/packages/73/78/eb2e5d067d4c054451e33eaece74cbdcb58236dc60516e73d783dae34c7e/ndindex-1.10.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5c3634a8df43e7928122225a3d64d850c8957bd1edf2e403907deacb478af27b", size = 614419, upload-time = "2025-11-19T20:39:43.254Z" }, + { url = "https://files.pythonhosted.org/packages/78/51/261bfb49eb7920c2a7314cacba5821930a529911dce48c7c6cd786096a5a/ndindex-1.10.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9d581f931e61f182478f18bdf5edd3955899df5da4892ed0d5de547a4cfd5b6f", size = 1587517, upload-time = "2025-11-19T20:39:44.809Z" }, + { url = "https://files.pythonhosted.org/packages/ec/37/084a332ecdf8b0049151bd78001a7baf2daf7f500d043beb8a1f95d0f4e3/ndindex-1.10.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:78ce45106ebf67aeba99714818c721d8fd5fb9534daebd2565665a2d64b50fc9", size = 1635372, upload-time = "2025-11-19T20:39:47.231Z" }, + { url = "https://files.pythonhosted.org/packages/28/f4/716580fbb03018ab1daa86ed12c1925c67e79689db5fee82393e840758a2/ndindex-1.10.1-cp314-cp314t-win32.whl", hash = "sha256:fe5341e24dc992b09c258456ac90a09a6d25efdc2cb86dcc91d32c8891e1df9a", size = 162186, upload-time = "2025-11-19T20:39:48.81Z" }, + { url = "https://files.pythonhosted.org/packages/4d/20/28f669c09a470e7f523b0cc10b94336664d9648594015e3f2a1ec29047b1/ndindex-1.10.1-cp314-cp314t-win_amd64.whl", hash = "sha256:37f87f0e7690ae0324334740e0661d6297f2e62c9bf925127d249fb7eddd0ad8", size = 171077, upload-time = "2025-11-19T20:39:50.108Z" }, ] [[package]] @@ -3742,26 +3676,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef", size = 13307, upload-time = "2024-02-14T23:35:16.286Z" }, ] -[[package]] -name = "npe2" -version = "0.8.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "build" }, - { name = "platformdirs" }, - { name = "psygnal" }, - { name = "pydantic" }, - { name = "pydantic-extra-types" }, - { name = "pyyaml" }, - { name = "rich" }, - { name = "tomli-w" }, - { name = "typer" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/29/0a/1a6ed44b038484a064a0ac8e5f96aae6ddb8768789145cf7e65e699b324b/npe2-0.8.2.tar.gz", hash = "sha256:6e41cc1f2c873257d864980dd281b5bb649a84cef02feeb0cdda1a9d23fd8f8b", size = 122768, upload-time = "2026-04-04T20:55:11.9Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/52/a6/f318fbc7bbb62361d36cb694f399f765f57fb282fdadc3aa2fef4dafd62d/npe2-0.8.2-py3-none-any.whl", hash = "sha256:80eff5fef50352cf0f3407c4c1122a7ae186aede40a21fd595cf91988cd55a9d", size = 93921, upload-time = "2026-04-04T20:55:10.552Z" }, -] - [[package]] name = "numba" version = "0.65.1" @@ -3780,6 +3694,14 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a0/22/b8d873f6466b20aa563fc9b33acd48dec89a07803ddaa2f1c8ca1cd33126/numba-0.65.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c09f49117ef255e1f1c6dad0c7a1ed39868243862a73be5706793241a3755f1b", size = 3810619, upload-time = "2026-04-24T02:02:36.041Z" }, { url = "https://files.pythonhosted.org/packages/62/08/e16a8b5d9a018962ebb5c66be662317cde32b9f5dab08441f90bed5522fb/numba-0.65.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:594a8680b3fadac99e97e489b1fd89007177e5336713745c3b769528c635a464", size = 3509783, upload-time = "2026-04-24T02:02:38.245Z" }, { url = "https://files.pythonhosted.org/packages/fd/a5/03c970d57f4c1741354837353ce39fb5206952ae1dba8922d29c86f64805/numba-0.65.1-cp313-cp313-win_amd64.whl", hash = "sha256:85be74c0d036842699a30058f82fb88fc5ffdc59f7615cab5792ea92914c9b62", size = 2750534, upload-time = "2026-04-24T02:02:39.903Z" }, + { url = "https://files.pythonhosted.org/packages/4f/2e/8aed9b726d9ba5f11ad287645fd479e88278db3060a25cb1225d730eb2b7/numba-0.65.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:33f5eb68eb1c843511615d14663ce60258525d6a4c65ab040e2c2b0c4cf17450", size = 2681554, upload-time = "2026-04-24T02:02:41.812Z" }, + { url = "https://files.pythonhosted.org/packages/87/96/f3eb235fafa82a34e2ab5dd7dc9ffff998ebf5f0bbc23fa56a96aeb44da6/numba-0.65.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:71e73029bf53a62cc6afcf96be4bd942290d8b4c55f0a454fb536158115790f7", size = 3779602, upload-time = "2026-04-24T02:02:43.726Z" }, + { url = "https://files.pythonhosted.org/packages/09/90/b0f09b48752d23640b8284f22aa597737e8adaddc7fbfacc4708b7f73a4c/numba-0.65.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a07635e0be926b9bdbffb09137c230fb13f6ec0e564914ba937cee12ce3eb35", size = 3479532, upload-time = "2026-04-24T02:02:45.427Z" }, + { url = "https://files.pythonhosted.org/packages/56/46/3f7fc04fb853559e74b210e0b62c19974ec844cefec611f9e535f4da3761/numba-0.65.1-cp314-cp314-win_amd64.whl", hash = "sha256:2a20fcdabdefbdacf88d85caf70c3b18c4bcb7ebb8f82e6a19486383dd26ab63", size = 2752637, upload-time = "2026-04-24T02:02:47.664Z" }, + { url = "https://files.pythonhosted.org/packages/81/7b/c1a341a9067367778f4152a5f01061cf281fb09582c92c510ec4918cabf6/numba-0.65.1-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:548dd4b3a4508d5062768d1514b2cd7b015f9a25ec7af651c50dee243965e652", size = 2684600, upload-time = "2026-04-24T02:02:49.653Z" }, + { url = "https://files.pythonhosted.org/packages/03/36/98ddbcf3e4f04a6dd07e1c67249955920579ba4af6bb6868e3088f4ed282/numba-0.65.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:78abc28feff2c2ff8307fff3975b6438352759c9acb797ecd6b1fb6e7e39e31d", size = 3817198, upload-time = "2026-04-24T02:02:51.266Z" }, + { url = "https://files.pythonhosted.org/packages/a3/83/0dad21057ece5a835599f5d24099b091703995e23dbbf894f259e91c010b/numba-0.65.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee7676cb389555805f9b9a1840cbcd1ea6c8bd5376ab6918e3a29c5ea1dbda20", size = 3533862, upload-time = "2026-04-24T02:02:52.987Z" }, + { url = "https://files.pythonhosted.org/packages/32/36/8be7118ffd4c8440881046eac3d0982cc5ab42909508cf5d67024d62a2e4/numba-0.65.1-cp314-cp314t-win_amd64.whl", hash = "sha256:20609346e3bd75204950dcbbfe383a8d7dbf4902f442aedbf00f97fef4aa8f38", size = 2758237, upload-time = "2026-04-24T02:02:54.612Z" }, ] [[package]] @@ -3835,6 +3757,22 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/1e/ce/0d4fcd31ab49319740d934fba1734d7dad13aa485532ca754e555ca16c8b/numexpr-2.14.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:67ea4771029ce818573b1998f5ca416bd255156feea017841b86176a938f7d19", size = 1474214, upload-time = "2025-10-13T16:15:38.893Z" }, { url = "https://files.pythonhosted.org/packages/b7/47/b2a93cbdb3ba4e009728ad1b9ef1550e2655ea2c86958ebaf03b9615f275/numexpr-2.14.1-cp313-cp313t-win32.whl", hash = "sha256:15015d47d3d1487072d58c0e7682ef2eb608321e14099c39d52e2dd689483611", size = 167676, upload-time = "2025-10-13T16:17:17.351Z" }, { url = "https://files.pythonhosted.org/packages/86/99/ee3accc589ed032eea68e12172515ed96a5568534c213ad109e1f4411df1/numexpr-2.14.1-cp313-cp313t-win_amd64.whl", hash = "sha256:94c711f6d8f17dfb4606842b403699603aa591ab9f6bf23038b488ea9cfb0f09", size = 161096, upload-time = "2025-10-13T16:17:19.174Z" }, + { url = "https://files.pythonhosted.org/packages/ac/36/9db78dfbfdfa1f8bf0872993f1a334cdd8fca5a5b6567e47dcb128bcb7c2/numexpr-2.14.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ede79f7ff06629f599081de644546ce7324f1581c09b0ac174da88a470d39c21", size = 162848, upload-time = "2025-10-13T16:16:46.216Z" }, + { url = "https://files.pythonhosted.org/packages/13/c1/a5c78ae637402c5550e2e0ba175275d2515d432ec28af0cdc23c9b476e65/numexpr-2.14.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2eac7a5a2f70b3768c67056445d1ceb4ecd9b853c8eda9563823b551aeaa5082", size = 152270, upload-time = "2025-10-13T16:16:47.92Z" }, + { url = "https://files.pythonhosted.org/packages/9a/ed/aabd8678077848dd9a751c5558c2057839f5a09e2a176d8dfcd0850ee00e/numexpr-2.14.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5aedf38d4c0c19d3cecfe0334c3f4099fb496f54c146223d30fa930084bc8574", size = 455918, upload-time = "2025-10-13T16:13:50.338Z" }, + { url = "https://files.pythonhosted.org/packages/88/e1/3db65117f02cdefb0e5e4c440daf1c30beb45051b7f47aded25b7f4f2f34/numexpr-2.14.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:439ec4d57b853792ebe5456e3160312281c3a7071ecac5532ded3278ede614de", size = 446512, upload-time = "2025-10-13T16:15:42.313Z" }, + { url = "https://files.pythonhosted.org/packages/9a/fb/7ceb9ee55b5f67e4a3e4d73d5af4c7e37e3c9f37f54bee90361b64b17e3f/numexpr-2.14.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e23b87f744e04e302d82ac5e2189ae20a533566aec76a46885376e20b0645bf8", size = 1417845, upload-time = "2025-10-13T16:13:53.836Z" }, + { url = "https://files.pythonhosted.org/packages/45/2d/9b5764d0eafbbb2889288f80de773791358acf6fad1a55767538d8b79599/numexpr-2.14.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:44f84e0e5af219dbb62a081606156420815890e041b87252fbcea5df55214c4c", size = 1466211, upload-time = "2025-10-13T16:15:48.985Z" }, + { url = "https://files.pythonhosted.org/packages/5d/21/204db708eccd71aa8bc55bcad55bc0fc6c5a4e01ad78e14ee5714a749386/numexpr-2.14.1-cp314-cp314-win32.whl", hash = "sha256:1f1a5e817c534539351aa75d26088e9e1e0ef1b3a6ab484047618a652ccc4fc3", size = 168835, upload-time = "2025-10-13T16:17:20.82Z" }, + { url = "https://files.pythonhosted.org/packages/4f/3e/d83e9401a1c3449a124f7d4b3fb44084798e0d30f7c11e60712d9b94cf11/numexpr-2.14.1-cp314-cp314-win_amd64.whl", hash = "sha256:587c41509bc373dfb1fe6086ba55a73147297247bedb6d588cda69169fc412f2", size = 162608, upload-time = "2025-10-13T16:17:22.228Z" }, + { url = "https://files.pythonhosted.org/packages/7f/d6/ec947806bb57836d6379a8c8a253c2aeaa602b12fef2336bfd2462bb4ed5/numexpr-2.14.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:ec368819502b64f190c3f71be14a304780b5935c42aae5bf22c27cc2cbba70b5", size = 163525, upload-time = "2025-10-13T16:16:50.133Z" }, + { url = "https://files.pythonhosted.org/packages/0d/77/048f30dcf661a3d52963a88c29b52b6d5ce996d38e9313a56a922451c1e0/numexpr-2.14.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7e87f6d203ac57239de32261c941e9748f9309cbc0da6295eabd0c438b920d3a", size = 152917, upload-time = "2025-10-13T16:16:52.055Z" }, + { url = "https://files.pythonhosted.org/packages/9e/d3/956a13e628d722d649fbf2fded615134a308c082e122a48bad0e90a99ce9/numexpr-2.14.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dd72d8c2a165fe45ea7650b16eb8cc1792a94a722022006bb97c86fe51fd2091", size = 466242, upload-time = "2025-10-13T16:13:55.795Z" }, + { url = "https://files.pythonhosted.org/packages/d6/dd/abe848678d82486940892f2cacf39e82eec790e8930d4d713d3f9191063b/numexpr-2.14.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70d80fcb418a54ca208e9a38e58ddc425c07f66485176b261d9a67c7f2864f73", size = 457149, upload-time = "2025-10-13T16:15:52.036Z" }, + { url = "https://files.pythonhosted.org/packages/fd/bb/797b583b5fb9da5700a5708ca6eb4f889c94d81abb28de4d642c0f4b3258/numexpr-2.14.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:edea2f20c2040df8b54ee8ca8ebda63de9545b2112872466118e9df4d0ae99f3", size = 1426493, upload-time = "2025-10-13T16:13:59.244Z" }, + { url = "https://files.pythonhosted.org/packages/77/c4/0519ab028fdc35e3e7ee700def7f2b4631b175cd9e1202bd7966c1695c33/numexpr-2.14.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:790447be6879a6c51b9545f79612d24c9ea0a41d537a84e15e6a8ddef0b6268e", size = 1474413, upload-time = "2025-10-13T16:15:59.211Z" }, + { url = "https://files.pythonhosted.org/packages/d4/4a/33044878c8f4a75213cfe9c11d4c02058bb710a7a063fe14f362e8de1077/numexpr-2.14.1-cp314-cp314t-win32.whl", hash = "sha256:538961096c2300ea44240209181e31fae82759d26b51713b589332b9f2a4117e", size = 169502, upload-time = "2025-10-13T16:17:23.829Z" }, + { url = "https://files.pythonhosted.org/packages/41/a2/5a1a2c72528b429337f49911b18c302ecd36eeab00f409147e1aa4ae4519/numexpr-2.14.1-cp314-cp314t-win_amd64.whl", hash = "sha256:a40b350cd45b4446076fa11843fa32bbe07024747aeddf6d467290bf9011b392", size = 163589, upload-time = "2025-10-13T16:17:25.696Z" }, ] [[package]] @@ -3875,18 +3813,27 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/8a/90/0ac3bc947217e66dec77e7cbc6a1979d1af70b6461b82f620d3bccd5e4c8/numpy-2.4.6-cp313-cp313t-win32.whl", hash = "sha256:29a287e0cf63ff528da061de6b9f64a4618da591ca1046aafc54062e40ca7eab", size = 6084971, upload-time = "2026-05-18T23:35:29.387Z" }, { url = "https://files.pythonhosted.org/packages/77/71/5673e351671a1d2bd6063b91b44f70c0affea7d1516fa7a6572941ba4aa1/numpy-2.4.6-cp313-cp313t-win_amd64.whl", hash = "sha256:25c692919ac5a01f170a3bfcd62d745b24fd095c353d50812637d6fcab442e75", size = 12458532, upload-time = "2026-05-18T23:35:32.175Z" }, { url = "https://files.pythonhosted.org/packages/3f/88/19d3503c5046e688f049274b27a3ef3d771152fa80d3ba3d01a3dff61abe/numpy-2.4.6-cp313-cp313t-win_arm64.whl", hash = "sha256:1e978ec1e8bd0e0e4de6bb75de9d30cbb74db6b6a2bb727618613703ca0167dd", size = 10291881, upload-time = "2026-05-18T23:35:35.465Z" }, -] - -[[package]] -name = "numpydoc" -version = "1.10.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "sphinx" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/e9/3c/dfccc9e7dee357fb2aa13c3890d952a370dd0ed071e0f7ed62ed0df567c1/numpydoc-1.10.0.tar.gz", hash = "sha256:3f7970f6eee30912260a6b31ac72bba2432830cd6722569ec17ee8d3ef5ffa01", size = 94027, upload-time = "2025-12-02T16:39:12.937Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/62/5e/3a6a3e90f35cea3853c45e5d5fb9b7192ce4384616f932cf7591298ab6e1/numpydoc-1.10.0-py3-none-any.whl", hash = "sha256:3149da9874af890bcc2a82ef7aae5484e5aa81cb2778f08e3c307ba6d963721b", size = 69255, upload-time = "2025-12-02T16:39:11.561Z" }, + { url = "https://files.pythonhosted.org/packages/f8/91/3ab2044d05fd16d343c5ac2e69b127f1b2854040dd20b193257c78028bd3/numpy-2.4.6-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06ca2f61ec4385a07a6977c55ba998a4466c123642b4a32694d3128fce18c079", size = 16683458, upload-time = "2026-05-18T23:35:38.353Z" }, + { url = "https://files.pythonhosted.org/packages/8e/62/764ce66fa4147ae6d73071a3abf804ffe606f174618697c571acdf26a7c9/numpy-2.4.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:38efbc8de75c7a0fc1ac190162d892787f3f47b57cc291231aafee36b80982b7", size = 14704559, upload-time = "2026-05-18T23:35:42.14Z" }, + { url = "https://files.pythonhosted.org/packages/60/61/23f27c172f022e04025b7dc2367f4d63c1a398120607ec896228649a6f48/numpy-2.4.6-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:d581b735e177fdcdce6fed8e7e8880a3fb6ee4e3653a3ac6af01c6f4c03effc5", size = 5209716, upload-time = "2026-05-18T23:35:45.377Z" }, + { url = "https://files.pythonhosted.org/packages/03/71/21cf70dc6ea3e3acb95fc53a265b2fc248b981f0194ceb5b475271b8809d/numpy-2.4.6-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:0a041d3d761dc3c35cc56ce0351506a02bcbc25f7b169f652435141a17db9096", size = 6543947, upload-time = "2026-05-18T23:35:47.926Z" }, + { url = "https://files.pythonhosted.org/packages/d5/91/64288395ee1799bd2e0b04a305dce9666da90c961e1f3fe982a05ee1c036/numpy-2.4.6-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40fdc1ae7125e518ea98e53e69a4ebc27e1fd50510c47b7ea130cf21e5e1d42b", size = 15685197, upload-time = "2026-05-18T23:35:50.863Z" }, + { url = "https://files.pythonhosted.org/packages/f3/eb/ebffaa97dc55502df69584a8f0dcf07f69a3e0b3e2323670a2722db9aa39/numpy-2.4.6-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a2c306dea656c12c68f51f4cea133cbe78ca7435eb28c735eac1d3ebe73be6e8", size = 16638245, upload-time = "2026-05-18T23:35:54.752Z" }, + { url = "https://files.pythonhosted.org/packages/b8/0b/54f9da33128d7e350fab89c7455902eeae70349ee52bddb448dc4a576f45/numpy-2.4.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:33111801a01c12a8a1e3721f0a9232f8cfc8ae2c6b7098167e6f623c6073f402", size = 17036587, upload-time = "2026-05-18T23:35:58.355Z" }, + { url = "https://files.pythonhosted.org/packages/b6/f0/fdebc1052db1cc37c64beb22072d67cd6d1c71adca1299f53dec2b5e20d3/numpy-2.4.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ae506e6902902557576a26ff33eda8695e7ecb3cb36c3b573a0765dee114ebdb", size = 18363226, upload-time = "2026-05-18T23:36:02.845Z" }, + { url = "https://files.pythonhosted.org/packages/aa/b4/298628d98c72b57e57f7165ae6a481a1deaf6f3c28262a6e4c739c275930/numpy-2.4.6-cp314-cp314-win32.whl", hash = "sha256:aaf159caa35993cb1f56fb9b8e4610d35758e7ca005412eb1daa856a78c9c4b1", size = 6010196, upload-time = "2026-05-18T23:36:05.92Z" }, + { url = "https://files.pythonhosted.org/packages/df/ac/46de6dda46478f7942f839e094970be2d4a861e005c4b3bf07c92e291a09/numpy-2.4.6-cp314-cp314-win_amd64.whl", hash = "sha256:b507f5c4c1d508876d1819b6bf9a49d365b96320b5d4993426b33a23ca4b8261", size = 12450334, upload-time = "2026-05-18T23:36:09.107Z" }, + { url = "https://files.pythonhosted.org/packages/78/92/b8b798ac784102c0da830d2257d59358e3d3d90d1e2b3f2575dad976c5cf/numpy-2.4.6-cp314-cp314-win_arm64.whl", hash = "sha256:6f41ae150c4e32db4f3310cdaf64b1593a03dbabe29eec77fc9b50fe64061df6", size = 10495678, upload-time = "2026-05-18T23:36:12.766Z" }, + { url = "https://files.pythonhosted.org/packages/30/34/ec28d1aa8115971537c01469ab2011ee96827930f0a124de1000cc2a7ed7/numpy-2.4.6-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ece3d2cfe132e7d51f44a832b303895e6f2d499c5e74dfbdb06ee246147a304a", size = 14823672, upload-time = "2026-05-18T23:36:16.473Z" }, + { url = "https://files.pythonhosted.org/packages/16/bd/f6d1fede4e54e8042a7ff97bb495510f3c220f94bcd9e8b228e87c92cc0d/numpy-2.4.6-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:e3e5193ef5a3dc73bceee50f7fdc2c90dbb76c42df8d8fae3d1067a583df579e", size = 5328731, upload-time = "2026-05-18T23:36:19.767Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f0/e105b9e2fd728a9910103884decd6951d9dd73896b914a98d9a231de02ee/numpy-2.4.6-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:17f9ade344e7d9b464a084d69bcf18fc691cb1db67c62ed80820bf4926d78f0e", size = 6649805, upload-time = "2026-05-18T23:36:22.266Z" }, + { url = "https://files.pythonhosted.org/packages/82/dd/1206a7ca6ab15e3f02069707ca96222e202af681bb73756da7527f3cb837/numpy-2.4.6-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cd5ffd25db4e7ba6a375693b3fc0fc1791ec636c17db3720da19bde7180ec43", size = 15730496, upload-time = "2026-05-18T23:36:25.713Z" }, + { url = "https://files.pythonhosted.org/packages/51/e7/38d3ea825dcab85a591734decb2f6c67caa7c8367d374df1a1c3842f9b07/numpy-2.4.6-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7d92c3819208a60205a12a245c91ad70cb0a85336659b19b834205573ac8456e", size = 16679616, upload-time = "2026-05-18T23:36:29.652Z" }, + { url = "https://files.pythonhosted.org/packages/93/b7/caabfdf53edf663e0b4eb74d7d405d83baef09eb5e83bcd32d601d72b93e/numpy-2.4.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e85b752a1e912b70eaad4fafbd4d1238007ab221de2009b9a2f5ae7461239895", size = 17085145, upload-time = "2026-05-18T23:36:33.449Z" }, + { url = "https://files.pythonhosted.org/packages/f9/45/68d7c33a6bcf3e5aa3bdbd57a367e6f615286dfd6482f97e8ffeb734306e/numpy-2.4.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:29cb7f67d10b479ff07c17d33e39f78c07f71c40ef30d63c153d340e96cd3fb4", size = 18403813, upload-time = "2026-05-18T23:36:37.369Z" }, + { url = "https://files.pythonhosted.org/packages/9c/50/0753655aa844c99cd9e018aacf76f130f1bd81d881bb74bc0aef5d73a8ba/numpy-2.4.6-cp314-cp314t-win32.whl", hash = "sha256:260a5d70215b61ab4fadf5c7baacd64821842975eea312125ed3c39a6391b063", size = 6156982, upload-time = "2026-05-18T23:36:40.817Z" }, + { url = "https://files.pythonhosted.org/packages/b2/d4/7c67becf668f973cb490cec3e98dfd799d866f9c989a54d355672cfa0db6/numpy-2.4.6-cp314-cp314t-win_amd64.whl", hash = "sha256:81a1cca95ed5bb92aa8b10dd2cdc9a0d3853a50fad926c28b5d7e8ea54389627", size = 12638908, upload-time = "2026-05-18T23:36:43.996Z" }, + { url = "https://files.pythonhosted.org/packages/43/bb/e1c71a4295b1b1d1393d50dbb4f2a36283c6859d9d3892e84f00ec5a91d5/numpy-2.4.6-cp314-cp314t-win_arm64.whl", hash = "sha256:0c9136e14ed34a9e343a31c533d78a9813a69a3148332bce5e9821cb2f996e66", size = 10565867, upload-time = "2026-05-18T23:36:47.114Z" }, ] [[package]] @@ -3894,7 +3841,7 @@ name = "nvidia-cublas" version = "13.1.1.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cuda-nvrtc", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "nvidia-cuda-nvrtc" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/a7/a1/0bd24ee8c8d03adac032fd2909426a00c88f8c57961b1277ded97f91119f/nvidia_cublas-13.1.1.3-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:b7a210458267ac818974c53038fbec2e969d5c99f305ab15c72522fa9f001dd5", size = 542848918, upload-time = "2026-04-08T18:46:22.985Z" }, @@ -3933,7 +3880,7 @@ name = "nvidia-cudnn-cu13" version = "9.20.0.48" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cublas", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "nvidia-cublas" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/56/c5/83384d846b2fd17c44bd499b36c75a45ed4f095fbbb2252294e89cea5c5c/nvidia_cudnn_cu13-9.20.0.48-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:e31454ae00094b0c55319d9d15b6fa2fc50a9e1c0f5c8c80fb75258234e731e1", size = 444574296, upload-time = "2026-03-09T19:28:27.751Z" }, @@ -3945,7 +3892,7 @@ name = "nvidia-cufft" version = "12.0.0.61" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-nvjitlink", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "nvidia-nvjitlink" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/8b/ae/f417a75c0259e85c1d2f83ca4e960289a5f814ed0cea74d18c353d3e989d/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2708c852ef8cd89d1d2068bdbece0aa188813a0c934db3779b9b1faa8442e5f5", size = 214053554, upload-time = "2025-09-04T08:31:38.196Z" }, @@ -3975,9 +3922,9 @@ name = "nvidia-cusolver" version = "12.0.4.66" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cublas", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, - { name = "nvidia-cusparse", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, - { name = "nvidia-nvjitlink", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "nvidia-cublas" }, + { name = "nvidia-cusparse" }, + { name = "nvidia-nvjitlink" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/c8/c3/b30c9e935fc01e3da443ec0116ed1b2a009bb867f5324d3f2d7e533e776b/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:02c2457eaa9e39de20f880f4bd8820e6a1cfb9f9a34f820eb12a155aa5bc92d2", size = 223467760, upload-time = "2025-09-04T08:33:04.222Z" }, @@ -3989,7 +3936,7 @@ name = "nvidia-cusparse" version = "12.6.3.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-nvjitlink", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "nvidia-nvjitlink" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/f8/94/5c26f33738ae35276672f12615a64bd008ed5be6d1ebcb23579285d960a9/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:80bcc4662f23f1054ee334a15c72b8940402975e0eab63178fc7e670aa59472c", size = 162155568, upload-time = "2025-09-04T08:33:42.864Z" }, @@ -4051,42 +3998,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a8/64/3708a90d1ebe202ffdeb7185f878a3c84d15c2b2c31858da2ce0583e2def/nvidia_nvtx-13.0.85-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cb7780edb6b14107373c835bf8b72e7a178bac7367e23da7acb108f973f157a6", size = 148878, upload-time = "2025-09-04T08:28:53.627Z" }, ] -[[package]] -name = "ome-zarr" -version = "0.18.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "aiohttp" }, - { name = "dask" }, - { name = "deprecated" }, - { name = "fsspec", extra = ["s3"] }, - { name = "numpy" }, - { name = "ome-zarr-models" }, - { name = "rangehttpserver" }, - { name = "requests" }, - { name = "scikit-image" }, - { name = "toolz" }, - { name = "zarr" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/59/98/f39cf0ec00ad64996ed2d2d6059d15a30c7b8f559cd2a216589885001a6a/ome_zarr-0.18.0.tar.gz", hash = "sha256:5cc0fc682b0c177fa32e54f4479b2436f79850a171e83ad4c6b08fec32e66cd0", size = 106039, upload-time = "2026-06-17T16:22:07.76Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/20/be/2cf9389c9a7b80ceefae88bd713afa6a4b488cb47e524e7dadae44260efd/ome_zarr-0.18.0-py3-none-any.whl", hash = "sha256:aaf6ea6ac5790623290210efc566ad49f92da170b50b07e9113b6b06a0870cc5", size = 57947, upload-time = "2026-06-17T16:22:06.732Z" }, -] - -[[package]] -name = "ome-zarr-models" -version = "1.6" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pydantic" }, - { name = "pydantic-zarr" }, - { name = "zarr" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/3d/e7/c37b8896a24eabc76d6a5e7855f722792de5bdf3f5ccc562001738be4f7e/ome_zarr_models-1.6.tar.gz", hash = "sha256:00735ad939d2b5f6a4f583cc19af1e8a5247fa1e93f1f08191143cd913b9633a", size = 106913, upload-time = "2026-03-10T10:14:28.369Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/5b/fc/7650df09dce0edfbaa1f2898c5eb0e0523ae5964dadb83855beb52166505/ome_zarr_models-1.6-py3-none-any.whl", hash = "sha256:d855a6fe885aa2613f64cd124ff8453d75854531bb3282eeaa916e976c7bcf66", size = 64251, upload-time = "2026-03-10T10:14:27.177Z" }, -] - [[package]] name = "omegaconf" version = "2.3.0" @@ -4123,6 +4034,11 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/49/2e/27affcac63eaf2ef183a44fd1a1354b11da64a6c72fe6f3fdcf5571bcee5/onnx-1.21.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b58a4cfec8d9311b73dc083e4c1fa362069267881144c05139b3eba5dc3a840", size = 17617687, upload-time = "2026-03-27T21:33:12.619Z" }, { url = "https://files.pythonhosted.org/packages/1c/5c/ac8ed15e941593a3672ce424280b764979026317811f2e8508432bfc3429/onnx-1.21.0-cp313-cp313t-win_amd64.whl", hash = "sha256:1a9baf882562c4cebf79589bebb7cd71a20e30b51158cac3e3bbaf27da6163bd", size = 16449402, upload-time = "2026-03-27T21:33:15.555Z" }, { url = "https://files.pythonhosted.org/packages/0e/aa/d2231e0dcaad838217afc64c306c8152a080134d2034e247cc973d577674/onnx-1.21.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bba12181566acf49b35875838eba49536a327b2944664b17125577d230c637ad", size = 16408273, upload-time = "2026-03-27T21:33:18.599Z" }, + { url = "https://files.pythonhosted.org/packages/bf/0a/8905b14694def6ad23edf1011fdd581500384062f8c4c567e114be7aa272/onnx-1.21.0-cp314-cp314t-macosx_12_0_universal2.whl", hash = "sha256:7ee9d8fd6a4874a5fa8b44bbcabea104ce752b20469b88bc50c7dcf9030779ad", size = 17975331, upload-time = "2026-03-27T21:33:21.69Z" }, + { url = "https://files.pythonhosted.org/packages/61/28/f4e401e5199d1b9c8b76c7e7ae1169e050515258e877b58fa8bb49d3bdcc/onnx-1.21.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5489f25fe461e7f32128218251a466cabbeeaf1eaa791c79daebf1a80d5a2cc9", size = 17537430, upload-time = "2026-03-27T21:33:24.547Z" }, + { url = "https://files.pythonhosted.org/packages/cf/cf/5d13320eb3660d5af360ea3b43aa9c63a70c92a9b4d1ea0d34501a32fcb8/onnx-1.21.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:db17fc0fec46180b6acbd1d5d8650a04e5527c02b09381da0b5b888d02a204c8", size = 17617662, upload-time = "2026-03-27T21:33:27.418Z" }, + { url = "https://files.pythonhosted.org/packages/4d/50/3eaa1878338247be021e6423696813d61e77e534dccbd15a703a144e703d/onnx-1.21.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19d9971a3e52a12968ae6c70fd0f86c349536de0b0c33922ecdbe52d1972fe60", size = 16463688, upload-time = "2026-03-27T21:33:30.229Z" }, + { url = "https://files.pythonhosted.org/packages/a7/48/38d46b43bbb525e0b6a4c2c4204cc6795d67e45687a2f7403e06d8e7053d/onnx-1.21.0-cp314-cp314t-win_arm64.whl", hash = "sha256:efba467efb316baf2a9452d892c2f982b9b758c778d23e38c7f44fa211b30bb9", size = 16423387, upload-time = "2026-03-27T21:33:33.446Z" }, ] [[package]] @@ -4157,6 +4073,9 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/dd/97/fe8979f44b9275654b42f7bb556e30789b71a1b22998c83b540df2b1b774/onnxruntime_gpu-1.26.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cfda2fad535595bfc3e570eb588092717711dcb2957656d814695e0c9ceb1508", size = 276974871, upload-time = "2026-05-08T19:15:58.052Z" }, { url = "https://files.pythonhosted.org/packages/67/3f/59f1777a394625ecc9a85636de57dc47c25dbb5f888da050f1463955a0ce/onnxruntime_gpu-1.26.0-cp313-cp313-win_amd64.whl", hash = "sha256:6ab9f9c741d2e239b2e321ab0d389c04329d4ab7f11e3b92dd3aa7db1c59dee4", size = 226548083, upload-time = "2026-05-08T19:09:44.408Z" }, { url = "https://files.pythonhosted.org/packages/89/96/360328e3c463f7ea08e853c4239c397e83363dd0204de71a710dc1a544bd/onnxruntime_gpu-1.26.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bcf6f347cad9f88a9a625c2b352cf9de927528aedb627ebbc089a201f1990b94", size = 276992052, upload-time = "2026-05-08T19:16:09.892Z" }, + { url = "https://files.pythonhosted.org/packages/fd/c8/aa2dc0e79bba577f37d5448bcb32fea79977e07506684d8138c19a0f1077/onnxruntime_gpu-1.26.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e6e4fb1ec9ae1cf456534d9115f106ab2a1ae96fa513b4ed0f4795302b4a2c6", size = 276978254, upload-time = "2026-05-08T19:16:22.096Z" }, + { url = "https://files.pythonhosted.org/packages/41/e7/923298431e669567d7ccc2a4c898b6534a47641a051569fd97165fe6d9b8/onnxruntime_gpu-1.26.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e592439b0183d303c2374517b5b392599a3d50b2dc9de949b9b15731ac921c9", size = 229142768, upload-time = "2026-05-08T19:09:54.589Z" }, + { url = "https://files.pythonhosted.org/packages/97/91/93ffe5431d154989f5e04864a25a97eea480997d771232bcbbc538188241/onnxruntime_gpu-1.26.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:56dc7b73954ff4bdc71f5b8ab306b6f61be5d007881b6ef423a609e2b9cd088b", size = 276991545, upload-time = "2026-05-08T19:16:33.347Z" }, ] [[package]] @@ -4230,6 +4149,21 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/5f/cc/2d10025f9056d376e4127ec05a5808b218d46f035fdc08178a5411b34250/orjson-3.11.9-cp313-cp313-win32.whl", hash = "sha256:d4087e5c0209a0a8efe4de3303c234b9c44d1174161dcd851e8eea07c7560b32", size = 131613, upload-time = "2026-05-06T15:10:39.569Z" }, { url = "https://files.pythonhosted.org/packages/67/bd/2775ff28bfe883b9aa1ff348300542eb2ef1ee18d8ae0e3a49846817a865/orjson-3.11.9-cp313-cp313-win_amd64.whl", hash = "sha256:051b102c93b4f634e89f3866b07b9a9a98915ada541f4ec30f177067b2694979", size = 127086, upload-time = "2026-05-06T15:10:41.262Z" }, { url = "https://files.pythonhosted.org/packages/91/2b/d26799e580939e32a7da9a39531bc9e58e15ca32ffaa6a8cb3e9bb0d22cd/orjson-3.11.9-cp313-cp313-win_arm64.whl", hash = "sha256:cce9127885941bd28f080cecf1f1d288336b7e0d812c345b08be88b572796254", size = 126696, upload-time = "2026-05-06T15:10:42.651Z" }, + { url = "https://files.pythonhosted.org/packages/8e/eb/5da01e356015aee6ecfa1187ced87aef51364e306f5e695dd52719bf0e78/orjson-3.11.9-cp314-cp314-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:b6ef1979adc4bc243523f1a2ba91418030a8e29b0a99cbe7e0e2d6807d4dce6e", size = 228465, upload-time = "2026-05-06T15:10:44.097Z" }, + { url = "https://files.pythonhosted.org/packages/64/62/3e0e0c14c957133bcd855395c62b55ed4e3b0af23ffea11b032cb1dcbdb1/orjson-3.11.9-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:f36b7f32c7c0db4a719f1fc5824db4a9c6f8bd1a354debb91faf26ebf3a4c71e", size = 128364, upload-time = "2026-05-06T15:10:45.839Z" }, + { url = "https://files.pythonhosted.org/packages/5a/5a/07d8aa117211a8ed7630bda80c8c0b14d04e0f8dcf99bcf49656e4a710eb/orjson-3.11.9-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:08f4d8ebb44925c794e535b2bebc507cebf32209df81de22ae285fb0d8d66de0", size = 132063, upload-time = "2026-05-06T15:10:47.267Z" }, + { url = "https://files.pythonhosted.org/packages/d6/ec/4acaf21483e18aa945be74a474c74b434f284b549f275a0a39b9f98956e9/orjson-3.11.9-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6cc7923789694fd58f001cbcac7e47abc13af4d560ebbfcf3b41a8b1a0748124", size = 122356, upload-time = "2026-05-06T15:10:48.765Z" }, + { url = "https://files.pythonhosted.org/packages/13/d8/5f0555e7638801323b7a75850f92e7dfa891bc84fe27a1ba4449170d1200/orjson-3.11.9-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea5c46eb2d3af39e806b986f4b09d5c2706a1f5afde3cbf7544ce6616127173c", size = 129592, upload-time = "2026-05-06T15:10:50.13Z" }, + { url = "https://files.pythonhosted.org/packages/b6/30/ed9860412a3603ceb3c5955bfd72d28b9d0e7ba6ed81add14f83d7114236/orjson-3.11.9-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f5d89a2ed90731df3be64bab0aa44f78bff39fdc9d71c291f4a8023aa46425b7", size = 140491, upload-time = "2026-05-06T15:10:51.582Z" }, + { url = "https://files.pythonhosted.org/packages/d0/17/adc514dea7ac7c505527febf884934b815d34f0c7b8693c1a8b39c5c4a57/orjson-3.11.9-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:25e4aed0312d292c09f61af25bba34e0b2c88546041472b09088c39a4d828af1", size = 127309, upload-time = "2026-05-06T15:10:53.329Z" }, + { url = "https://files.pythonhosted.org/packages/76/3e/c0b690253f0b82d86e99949af13533363acfb5432ecb5d53dd5b3bce9c34/orjson-3.11.9-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aaea64f3f467d22e70eeed68bdccb3bc4f83f650446c4a03c59f2cba28a108db", size = 134030, upload-time = "2026-05-06T15:10:54.988Z" }, + { url = "https://files.pythonhosted.org/packages/c1/7a/bc82a0bb25e9faaf92dc4d9ef002732efc09737706af83e346788641d4a7/orjson-3.11.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a028425d1b440c5d92a6be1e1a020739dfe67ea87d96c6dbe828c1b30041728b", size = 141482, upload-time = "2026-05-06T15:10:56.663Z" }, + { url = "https://files.pythonhosted.org/packages/01/55/e69188b939f77d5d32a9833745ace31ea5ccae3ab613a1ec185d3cd2c4fb/orjson-3.11.9-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:5b192c6cf397e4455b11523c5cf2b18ed084c1bbd61b6c0926344d2129481972", size = 415178, upload-time = "2026-05-06T15:10:58.446Z" }, + { url = "https://files.pythonhosted.org/packages/2e/1a/b8a5a7ac527e80b9cb11d51e3f6689b709279183264b9ec5c7bc680bb8b5/orjson-3.11.9-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ea407d4ccf5891d667d045fecae97a7a1e5e87b3b97f97ae1803c2e741130be0", size = 148089, upload-time = "2026-05-06T15:11:00.441Z" }, + { url = "https://files.pythonhosted.org/packages/97/4e/00503f64204bf859b37213a63927028f30fb6268cd8677fb0a5ad48155e1/orjson-3.11.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5f63aaf97afd9f6dec5b1a68e1b8da12bfccb4cb9a9a65c3e0b6c847849e7586", size = 136921, upload-time = "2026-05-06T15:11:02.176Z" }, + { url = "https://files.pythonhosted.org/packages/0d/ba/a23b82a0a8d0ed7bed4e5f5035aae751cad4ff6a1e8d2ecd14d8860f5929/orjson-3.11.9-cp314-cp314-win32.whl", hash = "sha256:e30ab17845bb9fa54ccf67fa4f9f5282652d54faa6d17452f47d0f369d038673", size = 131638, upload-time = "2026-05-06T15:11:03.696Z" }, + { url = "https://files.pythonhosted.org/packages/f3/c3/0c6798456bade745c75c452342dabacce5798196483e77e643be1f53877d/orjson-3.11.9-cp314-cp314-win_amd64.whl", hash = "sha256:32ef5f4283a3be81913947d19608eacb7c6608026851123790cd9cc8982af34b", size = 127078, upload-time = "2026-05-06T15:11:05.123Z" }, + { url = "https://files.pythonhosted.org/packages/16/21/5a3f1e8913103b703a436a5664238e5b965ec392b555fe68943ea3691e6b/orjson-3.11.9-cp314-cp314-win_arm64.whl", hash = "sha256:eebdbdeef0094e4f5aefa20dcd4eb2368ab5e7a3b4edea27f1e7b2892e009cf9", size = 126687, upload-time = "2026-05-06T15:11:06.602Z" }, ] [[package]] @@ -4275,6 +4209,22 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e9/21/ea191195e587b18cf682e97f433f81b2d0fbe341380e80a3e0d6e4403c8e/pandas-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d26cbe1fcfc12e8fd900e2454163e466b2d3af84f7c75481df7683ffc073d870", size = 11350796, upload-time = "2026-05-11T18:53:32.056Z" }, { url = "https://files.pythonhosted.org/packages/64/69/f0eaaf54939f0e8c6768fd06be9af2cef9b36048b96dfb9e1b2c685a807e/pandas-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:3e91cec1879ada0624fc3dc9953c5cbd60208e59c0db28f540c5d6d47502422f", size = 11799741, upload-time = "2026-05-11T18:53:34.985Z" }, { url = "https://files.pythonhosted.org/packages/45/a4/865e0e510cae5fc2194de4db28be638952de942571ba9125934fd9c01d47/pandas-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:08d789b41f87e0905880e293cedf6197ce71fe67cc081358b1e148a491b9bd13", size = 10499958, upload-time = "2026-05-11T18:53:37.857Z" }, + { url = "https://files.pythonhosted.org/packages/86/54/effdcc3c0ff7a08037889200e148ebe94c16c4f653be078c7b3675955df1/pandas-3.0.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:3650109c0f22879df8bd6179ab9ee3d7f1d1d4e7e0094a3f0032d9f51e2e64ac", size = 10336065, upload-time = "2026-05-11T18:53:41.099Z" }, + { url = "https://files.pythonhosted.org/packages/68/10/bf2d6738d72748b961a3751ab89522d58c54efc36a8e1a12161216cd45cf/pandas-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:bab900348131a7db1f69a7309ef141fd5680f1487094193bcbbb61791573bf8f", size = 9926101, upload-time = "2026-05-11T18:53:43.515Z" }, + { url = "https://files.pythonhosted.org/packages/ae/e9/e35cf11c8a136e757b956f5f0efdcaa50aecde85ea055f1898dfc68262f3/pandas-3.0.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba7e08b9ac1d54569cd1e256e3668975ed624d6826f7b68df0342b012007bddb", size = 10457553, upload-time = "2026-05-11T18:53:46.394Z" }, + { url = "https://files.pythonhosted.org/packages/58/3b/1cdec6772bdbaf7b25dab360c59f03cadf05492dd724c6540af905389b07/pandas-3.0.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d71c63ae4ebdbf70209742096f1fc46a83a0613c99d4b23766cced9ff8cd62a", size = 10914065, upload-time = "2026-05-11T18:53:49.134Z" }, + { url = "https://files.pythonhosted.org/packages/c4/c2/1ef644445fcd72e3627bceec77e3560636f87ddce4ed841afe76b83b5bf9/pandas-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e3a2ec42c98ffa2565a67e08e218d06d72576d758d90facb7c00805194d8f360", size = 11459188, upload-time = "2026-05-11T18:53:52.527Z" }, + { url = "https://files.pythonhosted.org/packages/7e/49/4d8d4f42cbc9c4adc7a1870f269c02cbd6cd40d059622c06fb298addcbad/pandas-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:335f62418ed562cfc3c49e9e196375c28b729dcef8543abf4f9438e381bf3c76", size = 11982966, upload-time = "2026-05-11T18:53:55.043Z" }, + { url = "https://files.pythonhosted.org/packages/38/55/792619469bab9882d8bbd5865d45a72f6478762d04a9af4bf0d08c503e95/pandas-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:3c20a521bbb85902f79f7270c80a59e1b5452d96d170c034f207181870f97ac5", size = 9876755, upload-time = "2026-05-11T18:53:58.067Z" }, + { url = "https://files.pythonhosted.org/packages/2a/af/33c469653b0ba03b50c3a98192d4c07f0c75c66b263ceb097fce0ee97d31/pandas-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:a2d2dff8a04f3917b55ab3910c32990f8ddf7eceba114947838cefa976a68977", size = 9198658, upload-time = "2026-05-11T18:54:00.733Z" }, + { url = "https://files.pythonhosted.org/packages/a2/fa/b8c257bd76b8bd060c3a9151c1fca05e9b9c5e3af5d0f549c0356f6d143d/pandas-3.0.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:0d589105b3c14645af1738ff279b2995102d8f7a03b0a66dc8d95550eb513e04", size = 10787242, upload-time = "2026-05-11T18:54:03.564Z" }, + { url = "https://files.pythonhosted.org/packages/54/eb/f19206ffb0bf1919002969aa448b4702c6594845156a6f8050674855aac3/pandas-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:13fc1e853d9e04743d11ba75a985ccbc2a317fe07d8af61e445a6fd24dacd6a6", size = 10436369, upload-time = "2026-05-11T18:54:06.311Z" }, + { url = "https://files.pythonhosted.org/packages/fd/24/c7c39fb4fe22b71a0c2d78bf0c585c600092d85f94f086d2b3b2f6ca27e2/pandas-3.0.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:819959dab7bbd0049c15623fbac4e29a191b9528160a61fb1032242d8ced2d9c", size = 10358306, upload-time = "2026-05-11T18:54:09.085Z" }, + { url = "https://files.pythonhosted.org/packages/16/ec/dd2a9eb7fa1204df88c0864164e35b228ac581062ac612ba0a67fd812e4c/pandas-3.0.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:60ae316d3fd75d1858d450d0db0103ea2be3e7d4a95ec2f064f7e2ae63f7b028", size = 10758394, upload-time = "2026-05-11T18:54:11.956Z" }, + { url = "https://files.pythonhosted.org/packages/95/6e/00c61ea8e85b4f6d8d35e11852a1a4998fc7fafc91c6a602d1cc9c972d64/pandas-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bd3a518890b400d32f9023722dc9a9a5c969f00b415419a3c06c043f09bb5d7d", size = 11375717, upload-time = "2026-05-11T18:54:14.539Z" }, + { url = "https://files.pythonhosted.org/packages/31/89/8fc1c268969fac43688d65fd92e67df24bd128d53cb4d2eee534cd307399/pandas-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9c39be2d709d01fa972a0cabc522389fceca4f3969332ba25a7d6c5802cf976a", size = 11828897, upload-time = "2026-05-11T18:54:17.146Z" }, + { url = "https://files.pythonhosted.org/packages/56/3b/e7d20dea247a3e6dc0bd8a6953854afbedc03951def4e7371e05e7263e25/pandas-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4db8c527972a821cf5286b40ccc57642a39bc62e62022b42f99f8a67fca8c3a1", size = 10900855, upload-time = "2026-05-11T18:54:19.72Z" }, + { url = "https://files.pythonhosted.org/packages/0f/54/68a0978d1ef8502b8492099beaa6e7a0c1b32e3b5d4f677f5810cb08711c/pandas-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b2c95f8bfc1ee412bf482605d7bfd30c12d1d26bd59fdd91efeef1d4718decb1", size = 9466464, upload-time = "2026-05-11T18:54:22.754Z" }, ] [[package]] @@ -4334,7 +4284,7 @@ name = "pexpect" version = "4.9.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "ptyprocess", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "ptyprocess" }, ] sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } wheels = [ @@ -4402,21 +4352,31 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ad/4b/926ab182c07fccae9fcb120043464e1ff1564775ec8864f21a0ebce6ac25/pillow-12.2.0-cp313-cp313t-win32.whl", hash = "sha256:ee3120ae9dff32f121610bb08e4313be87e03efeadfc6c0d18f89127e24d0c24", size = 6379592, upload-time = "2026-04-01T14:44:40.336Z" }, { url = "https://files.pythonhosted.org/packages/c2/c4/f9e476451a098181b30050cc4c9a3556b64c02cf6497ea421ac047e89e4b/pillow-12.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:325ca0528c6788d2a6c3d40e3568639398137346c3d6e66bb61db96b96511c98", size = 7085542, upload-time = "2026-04-01T14:44:43.251Z" }, { url = "https://files.pythonhosted.org/packages/00/a4/285f12aeacbe2d6dc36c407dfbbe9e96d4a80b0fb710a337f6d2ad978c75/pillow-12.2.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e5a76d03a6c6dcef67edabda7a52494afa4035021a79c8558e14af25313d453", size = 2465765, upload-time = "2026-04-01T14:44:45.996Z" }, -] - -[[package]] -name = "pint" -version = "0.25.3" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "flexcache" }, - { name = "flexparser" }, - { name = "platformdirs" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/52/9d/b1379cdbd33a49d17d627bc24e2b63cca06a1c5343b38072d2889499e82e/pint-0.25.3.tar.gz", hash = "sha256:f8f5df6cf65314d74da1ade1bf96f8e3e4d0c41b51577ac53c49e7d44ca5acee", size = 255106, upload-time = "2026-03-19T21:57:08.72Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/1b/dd/a9fe6a0a09512da23951c68bf36466aeecd89def3183dc095edbc807ddc5/pint-0.25.3-py3-none-any.whl", hash = "sha256:27eb25143bd5de9fcc4d5a4b484f16faf6b4615aa93ece6b3373a8c1a3c1b97d", size = 307488, upload-time = "2026-03-19T21:57:07.022Z" }, + { url = "https://files.pythonhosted.org/packages/bf/98/4595daa2365416a86cb0d495248a393dfc84e96d62ad080c8546256cb9c0/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:3adc9215e8be0448ed6e814966ecf3d9952f0ea40eb14e89a102b87f450660d8", size = 4100848, upload-time = "2026-04-01T14:44:48.48Z" }, + { url = "https://files.pythonhosted.org/packages/0b/79/40184d464cf89f6663e18dfcf7ca21aae2491fff1a16127681bf1fa9b8cf/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:6a9adfc6d24b10f89588096364cc726174118c62130c817c2837c60cf08a392b", size = 4176515, upload-time = "2026-04-01T14:44:51.353Z" }, + { url = "https://files.pythonhosted.org/packages/b0/63/703f86fd4c422a9cf722833670f4f71418fb116b2853ff7da722ea43f184/pillow-12.2.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:6a6e67ea2e6feda684ed370f9a1c52e7a243631c025ba42149a2cc5934dec295", size = 3640159, upload-time = "2026-04-01T14:44:53.588Z" }, + { url = "https://files.pythonhosted.org/packages/71/e0/fb22f797187d0be2270f83500aab851536101b254bfa1eae10795709d283/pillow-12.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2bb4a8d594eacdfc59d9e5ad972aa8afdd48d584ffd5f13a937a664c3e7db0ed", size = 5312185, upload-time = "2026-04-01T14:44:56.039Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8c/1a9e46228571de18f8e28f16fabdfc20212a5d019f3e3303452b3f0a580d/pillow-12.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:80b2da48193b2f33ed0c32c38140f9d3186583ce7d516526d462645fd98660ae", size = 4695386, upload-time = "2026-04-01T14:44:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/70/62/98f6b7f0c88b9addd0e87c217ded307b36be024d4ff8869a812b241d1345/pillow-12.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22db17c68434de69d8ecfc2fe821569195c0c373b25cccb9cbdacf2c6e53c601", size = 6280384, upload-time = "2026-04-01T14:45:01.5Z" }, + { url = "https://files.pythonhosted.org/packages/5e/03/688747d2e91cfbe0e64f316cd2e8005698f76ada3130d0194664174fa5de/pillow-12.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7b14cc0106cd9aecda615dd6903840a058b4700fcb817687d0ee4fc8b6e389be", size = 8091599, upload-time = "2026-04-01T14:45:04.5Z" }, + { url = "https://files.pythonhosted.org/packages/f6/35/577e22b936fcdd66537329b33af0b4ccfefaeabd8aec04b266528cddb33c/pillow-12.2.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cbeb542b2ebc6fcdacabf8aca8c1a97c9b3ad3927d46b8723f9d4f033288a0f", size = 6396021, upload-time = "2026-04-01T14:45:07.117Z" }, + { url = "https://files.pythonhosted.org/packages/11/8d/d2532ad2a603ca2b93ad9f5135732124e57811d0168155852f37fbce2458/pillow-12.2.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4bfd07bc812fbd20395212969e41931001fd59eb55a60658b0e5710872e95286", size = 7083360, upload-time = "2026-04-01T14:45:09.763Z" }, + { url = "https://files.pythonhosted.org/packages/5e/26/d325f9f56c7e039034897e7380e9cc202b1e368bfd04d4cbe6a441f02885/pillow-12.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9aba9a17b623ef750a4d11b742cbafffeb48a869821252b30ee21b5e91392c50", size = 6507628, upload-time = "2026-04-01T14:45:12.378Z" }, + { url = "https://files.pythonhosted.org/packages/5f/f7/769d5632ffb0988f1c5e7660b3e731e30f7f8ec4318e94d0a5d674eb65a4/pillow-12.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:deede7c263feb25dba4e82ea23058a235dcc2fe1f6021025dc71f2b618e26104", size = 7209321, upload-time = "2026-04-01T14:45:15.122Z" }, + { url = "https://files.pythonhosted.org/packages/6a/7a/c253e3c645cd47f1aceea6a8bacdba9991bf45bb7dfe927f7c893e89c93c/pillow-12.2.0-cp314-cp314-win32.whl", hash = "sha256:632ff19b2778e43162304d50da0181ce24ac5bb8180122cbe1bf4673428328c7", size = 6479723, upload-time = "2026-04-01T14:45:17.797Z" }, + { url = "https://files.pythonhosted.org/packages/cd/8b/601e6566b957ca50e28725cb6c355c59c2c8609751efbecd980db44e0349/pillow-12.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:4e6c62e9d237e9b65fac06857d511e90d8461a32adcc1b9065ea0c0fa3a28150", size = 7217400, upload-time = "2026-04-01T14:45:20.529Z" }, + { url = "https://files.pythonhosted.org/packages/d6/94/220e46c73065c3e2951bb91c11a1fb636c8c9ad427ac3ce7d7f3359b9b2f/pillow-12.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:b1c1fbd8a5a1af3412a0810d060a78b5136ec0836c8a4ef9aa11807f2a22f4e1", size = 2554835, upload-time = "2026-04-01T14:45:23.162Z" }, + { url = "https://files.pythonhosted.org/packages/b6/ab/1b426a3974cb0e7da5c29ccff4807871d48110933a57207b5a676cccc155/pillow-12.2.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:57850958fe9c751670e49b2cecf6294acc99e562531f4bd317fa5ddee2068463", size = 5314225, upload-time = "2026-04-01T14:45:25.637Z" }, + { url = "https://files.pythonhosted.org/packages/19/1e/dce46f371be2438eecfee2a1960ee2a243bbe5e961890146d2dee1ff0f12/pillow-12.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d5d38f1411c0ed9f97bcb49b7bd59b6b7c314e0e27420e34d99d844b9ce3b6f3", size = 4698541, upload-time = "2026-04-01T14:45:28.355Z" }, + { url = "https://files.pythonhosted.org/packages/55/c3/7fbecf70adb3a0c33b77a300dc52e424dc22ad8cdc06557a2e49523b703d/pillow-12.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c0a9f29ca8e79f09de89293f82fc9b0270bb4af1d58bc98f540cc4aedf03166", size = 6322251, upload-time = "2026-04-01T14:45:30.924Z" }, + { url = "https://files.pythonhosted.org/packages/1c/3c/7fbc17cfb7e4fe0ef1642e0abc17fc6c94c9f7a16be41498e12e2ba60408/pillow-12.2.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1610dd6c61621ae1cf811bef44d77e149ce3f7b95afe66a4512f8c59f25d9ebe", size = 8127807, upload-time = "2026-04-01T14:45:33.908Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c3/a8ae14d6defd2e448493ff512fae903b1e9bd40b72efb6ec55ce0048c8ce/pillow-12.2.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a34329707af4f73cf1782a36cd2289c0368880654a2c11f027bcee9052d35dd", size = 6433935, upload-time = "2026-04-01T14:45:36.623Z" }, + { url = "https://files.pythonhosted.org/packages/6e/32/2880fb3a074847ac159d8f902cb43278a61e85f681661e7419e6596803ed/pillow-12.2.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e9c4f5b3c546fa3458a29ab22646c1c6c787ea8f5ef51300e5a60300736905e", size = 7116720, upload-time = "2026-04-01T14:45:39.258Z" }, + { url = "https://files.pythonhosted.org/packages/46/87/495cc9c30e0129501643f24d320076f4cc54f718341df18cc70ec94c44e1/pillow-12.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fb043ee2f06b41473269765c2feae53fc2e2fbf96e5e22ca94fb5ad677856f06", size = 6540498, upload-time = "2026-04-01T14:45:41.879Z" }, + { url = "https://files.pythonhosted.org/packages/18/53/773f5edca692009d883a72211b60fdaf8871cbef075eaa9d577f0a2f989e/pillow-12.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f278f034eb75b4e8a13a54a876cc4a5ab39173d2cdd93a638e1b467fc545ac43", size = 7239413, upload-time = "2026-04-01T14:45:44.705Z" }, + { url = "https://files.pythonhosted.org/packages/c9/e4/4b64a97d71b2a83158134abbb2f5bd3f8a2ea691361282f010998f339ec7/pillow-12.2.0-cp314-cp314t-win32.whl", hash = "sha256:6bb77b2dcb06b20f9f4b4a8454caa581cd4dd0643a08bacf821216a16d9c8354", size = 6482084, upload-time = "2026-04-01T14:45:47.568Z" }, + { url = "https://files.pythonhosted.org/packages/ba/13/306d275efd3a3453f72114b7431c877d10b1154014c1ebbedd067770d629/pillow-12.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6562ace0d3fb5f20ed7290f1f929cae41b25ae29528f2af1722966a0a02e2aa1", size = 7225152, upload-time = "2026-04-01T14:45:50.032Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6e/cf826fae916b8658848d7b9f38d88da6396895c676e8086fc0988073aaf8/pillow-12.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:aa88ccfe4e32d362816319ed727a004423aab09c5cea43c01a4b435643fa34eb", size = 2556579, upload-time = "2026-04-01T14:45:52.529Z" }, ] [[package]] @@ -4557,6 +4517,40 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/0a/aa/50fb0b5d3968b61a510926ff8b8465f1d6e976b3ab74496d7a4b9fc42515/propcache-0.5.2-cp313-cp313t-win32.whl", hash = "sha256:72d61e16dd78228b58c5d47be830ff3da7e5f139abdf0aef9d86cde1c5cf2191", size = 42546, upload-time = "2026-05-08T21:01:18.946Z" }, { url = "https://files.pythonhosted.org/packages/ae/4c/0ddbae64321bd4a95bcbfc19307238016b5b1fee645c84626c8d539e5b74/propcache-0.5.2-cp313-cp313t-win_amd64.whl", hash = "sha256:0958834041a0166d343b8d2cedcd8bcbaeb4fdbe0cf08320c5379f143c3be6e7", size = 46330, upload-time = "2026-05-08T21:01:20.162Z" }, { url = "https://files.pythonhosted.org/packages/00/d9/9cddc8efb78d8af264c5ec9f6d10b62f57c515feda8d321595f56010fb23/propcache-0.5.2-cp313-cp313t-win_arm64.whl", hash = "sha256:6de8bd93ddde9b992cf2b2e0d796d501a19026b5b9fd87356d7d0779531a8d96", size = 40521, upload-time = "2026-05-08T21:01:21.399Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ea/23ee535d90ce8bcc465a3028eb3cc0ce3bd1005f4bb27710b30587de798d/propcache-0.5.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:46088abff4cba581dea21ae0467a480526cb25aa5f3c269e909f800328bc3999", size = 94662, upload-time = "2026-05-08T21:01:22.683Z" }, + { url = "https://files.pythonhosted.org/packages/b5/06/c5a52f419b5d8972f8d46a7577476090d8e3263ff589ce40b5ca4968d5be/propcache-0.5.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fc88b26f08d634f7bc819a7852e5214f5802641ab8d9fd5326892292eee1993e", size = 53928, upload-time = "2026-05-08T21:01:23.986Z" }, + { url = "https://files.pythonhosted.org/packages/63/b1/4260d67d6bd85e58a66b72d54ce15d5de789b6f3870cc6bedf8ff9667401/propcache-0.5.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:97797ebb098e670a2f92dd66f32897e30d7615b14e7f59711de23e30a9072539", size = 54650, upload-time = "2026-05-08T21:01:25.305Z" }, + { url = "https://files.pythonhosted.org/packages/70/06/2f46c318e3307cd7a6a7481def374ce838c0fe20084b39dd54b0879d0e99/propcache-0.5.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba57fffe4ac99c5d30076161b5866336d97600769bad35cc68f7774b15298a4e", size = 59912, upload-time = "2026-05-08T21:01:26.545Z" }, + { url = "https://files.pythonhosted.org/packages/4c/29/fe1aebec2ce57ab985a9c382bded1124431f85078113aa222c5d278430d4/propcache-0.5.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:583c19759d9eec1e5b69e2fbef36a7d9c326041be9746cb822d335c8cedc2979", size = 63300, upload-time = "2026-05-08T21:01:27.937Z" }, + { url = "https://files.pythonhosted.org/packages/b4/18/2334b26768b6c82be8c69e83671b767d5ef426aa09b0cba6c2ea47816774/propcache-0.5.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d0326e2e5e1f3163fa306c834e48e8d490e5fae607a097a40c0648109b47ba80", size = 64208, upload-time = "2026-05-08T21:01:29.484Z" }, + { url = "https://files.pythonhosted.org/packages/2b/76/7f1bfd6afff4c5e38e36a3c6d68eb5f4b7311ea80baf693db78d95b603c4/propcache-0.5.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e00820e192c8dbebcafb383ebbf99030895f09905e7a0eb2e0340a0bcc2bc825", size = 61633, upload-time = "2026-05-08T21:01:31.068Z" }, + { url = "https://files.pythonhosted.org/packages/c4/46/b3ff8aba2b4953a3e50de2cf72f1b5748b8eca93b15f3dc2c84339084c09/propcache-0.5.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c66afea89b1e43725731d2004732a046fe6fe955d51f952c3e95a7314a284a39", size = 61724, upload-time = "2026-05-08T21:01:32.374Z" }, + { url = "https://files.pythonhosted.org/packages/c5/01/814cfcafbcff954f94c01cf30e097ddc88a076b5440fbcf4570753437d40/propcache-0.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d4dc37dec6c6cdad0b57881a5658fd14fbf53e333b1a86cf86559f190e1d9ec4", size = 60069, upload-time = "2026-05-08T21:01:33.67Z" }, + { url = "https://files.pythonhosted.org/packages/da/68/5c6f7622d510cc666a300687e06fd060c1a43361c0c9b20d284f06d8096a/propcache-0.5.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:5570dbcc97571c15f68068e529c92715a12f8d54030e272d264b377e22bd17a5", size = 57099, upload-time = "2026-05-08T21:01:34.915Z" }, + { url = "https://files.pythonhosted.org/packages/55/27/9cb0b4c679124085327957d42521c99dba04c88c90c3e55a6f0b633ebccc/propcache-0.5.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f814362777a9f841adddb200ecdf8f5cb1e5a3c4b7a86378edbd6ccb26edd702", size = 63391, upload-time = "2026-05-08T21:01:36.231Z" }, + { url = "https://files.pythonhosted.org/packages/f0/9d/7258aaa5bdf60fc6f27591eef6fe52768cb0beda7140be477c8b12c9794a/propcache-0.5.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:196913dea116aeb5a2ba95af4ddcb7ea85559ae07d8eee8751688310d09168c3", size = 61626, upload-time = "2026-05-08T21:01:37.545Z" }, + { url = "https://files.pythonhosted.org/packages/8e/0d/41c602003e8a9b16fe1e7eadf62c7bfba9d5474370b24200bf48b315f45f/propcache-0.5.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:6e7b8719005dd1175be4ab1cd25e9b98659a5e0347331506ec6760d2773a7fb5", size = 64781, upload-time = "2026-05-08T21:01:38.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f3/38e66b1856e9bd079deea015bc4a55f7767c0e4db2f7dcf69e7e680ba4ce/propcache-0.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:51f96d685ab16e88cab128cd37a52c5da540809c8b879fa047731bfcb4ad35a4", size = 62570, upload-time = "2026-05-08T21:01:40.415Z" }, + { url = "https://files.pythonhosted.org/packages/95/ca/bbfe9b910ce57dde8bb4876b4520fc02a4e89497c10de26be936758a3aaa/propcache-0.5.2-cp314-cp314-win32.whl", hash = "sha256:cc6fc3cc62e8501d3ed62894425040d2728ecddb1ed072737a5c70bd537aa9f0", size = 39436, upload-time = "2026-05-08T21:01:41.654Z" }, + { url = "https://files.pythonhosted.org/packages/61/d2/45c9defbaa1ea297035d9d4cce9e8f80daafbf19319c6007f157c6256ea9/propcache-0.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:81e3a30b0bb60caa22033dd0f8a3618d1d67356212514f62c57db75cb0ef410c", size = 42373, upload-time = "2026-05-08T21:01:43.041Z" }, + { url = "https://files.pythonhosted.org/packages/44/68/9ea5103f41d5217d7d6ec24db90018e23aebec070c3f9a6e54d12b841fd8/propcache-0.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:0d2c9bf8528f135dbb805ce027567e09164f7efa51a2be07458a2c0420f292d0", size = 38554, upload-time = "2026-05-08T21:01:44.336Z" }, + { url = "https://files.pythonhosted.org/packages/8a/81/fadf555f42d3b762eea8a53950b0489fdc0aa9da5f8ed9e10ce0a4e01b48/propcache-0.5.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:4bc8ff1feffc6a61c7002ffe84634c41b822e104990ae009f44a0834430070bb", size = 99395, upload-time = "2026-05-08T21:01:45.883Z" }, + { url = "https://files.pythonhosted.org/packages/f5/c9/c61e134a686949cf7971af3a390148b1156f7be81c73bc0cd12c873e2d48/propcache-0.5.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:79aa3ff0a9b566633b642fa9caf7e21ed1c13d6feca718187873f199e1514078", size = 56653, upload-time = "2026-05-08T21:01:47.307Z" }, + { url = "https://files.pythonhosted.org/packages/cb/73/daf935ea7048ddd7ec8eec5345b4a40b619d2d178b3c0a0900796bc3c794/propcache-0.5.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1b31822f4474c4036bae62de9402710051d431a606d6a0f907fec79935a071aa", size = 56914, upload-time = "2026-05-08T21:01:48.573Z" }, + { url = "https://files.pythonhosted.org/packages/79/9f/aba959b435ea18617edd7cf0a7ad0b9c574b8fc7e3d2cd55fb59cb255d33/propcache-0.5.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:13fef48778b5a2a756523fdb781326b028ca75e32858b04f2cdd19f394564917", size = 62567, upload-time = "2026-05-08T21:01:49.903Z" }, + { url = "https://files.pythonhosted.org/packages/6c/a1/859942de9a791ff42f6141736f5b37749b8f53e65edfa49638c67dd67e6a/propcache-0.5.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8b73ab70f1a3351fbc71f663b3e645af6dd0329100c353081cf69c37433fc6fe", size = 65542, upload-time = "2026-05-08T21:01:51.204Z" }, + { url = "https://files.pythonhosted.org/packages/b5/61/315bc0fd6c0fc7f80a528b8afd209e5fc4a875ea79571b91b8f50f442907/propcache-0.5.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5538d2c13d93e4698af7e092b57bc7298fd35d1d58e656ae18f23ee0d0378e03", size = 66845, upload-time = "2026-05-08T21:01:52.539Z" }, + { url = "https://files.pythonhosted.org/packages/47/f7/9f8122e3132e8e354ac41975ef8f1099be7d5a16bc7ae562734e993665c0/propcache-0.5.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cd645f03898405cabe694fb8bc35241e3a9c332ec85627584fe3de201452b335", size = 63985, upload-time = "2026-05-08T21:01:53.847Z" }, + { url = "https://files.pythonhosted.org/packages/c8/54/c317819ec157cbf6f35df9df9657a6f82daf34d5faf15948b2f639c2192e/propcache-0.5.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a473b3440261e0c60706e732b2ed2f517857344fc21bf48fdfe211e2d98eb285", size = 63999, upload-time = "2026-05-08T21:01:55.179Z" }, + { url = "https://files.pythonhosted.org/packages/5a/56/387e3f7dfce0a9233df41fb888aa1c30222cb4bbbf09537c02dd9bd85fe2/propcache-0.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7afa37062e6650640e932e4cc9297d81f9f42d9944029cc386b8247dea4da837", size = 62779, upload-time = "2026-05-08T21:01:57.489Z" }, + { url = "https://files.pythonhosted.org/packages/a1/9c/596784cb5824ed61ee960d3f8655a3f0993e107c6e98ab6c818b7fb92ccb/propcache-0.5.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:8a90efd5777e996e42d568db9ac740b944d691e565cbfd31b2f7832f9184b2b8", size = 59796, upload-time = "2026-05-08T21:01:58.736Z" }, + { url = "https://files.pythonhosted.org/packages/c2/3d/1a6cfa1726a48542c1e8784a0761421476a5b68e09b7f36bf95eb954aaba/propcache-0.5.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:f19bb891234d72535764d703bfed1153cc34f4214d5bd7150aee1eec9e8f4366", size = 66023, upload-time = "2026-05-08T21:02:00.228Z" }, + { url = "https://files.pythonhosted.org/packages/e4/0e/05fd6990369477076e4e280bcb970de760fddf0161a46e988bc95f7940ec/propcache-0.5.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:32775082acd2d807ee3db715c7770d38767b817870acfa08c29e057f3c4d5b56", size = 64448, upload-time = "2026-05-08T21:02:01.888Z" }, + { url = "https://files.pythonhosted.org/packages/cd/86/5f8da315a4309c62c10c0b2516b17492d5d3bbe1bb862b96604db67e2a37/propcache-0.5.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9282fb1a3bccd038da9f768b927b24a0c753e466c086b7c4f3c6982851eefb2d", size = 67329, upload-time = "2026-05-08T21:02:03.484Z" }, + { url = "https://files.pythonhosted.org/packages/da/d3/3368efe79ab21f0cdf86ef49895811c9cc933131d4cde1f28a624e22e712/propcache-0.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cc49723e2f60d6b32a0f0b08a3fd6d13203c07f1cd9566cfce0f12a917c967a2", size = 65172, upload-time = "2026-05-08T21:02:04.745Z" }, + { url = "https://files.pythonhosted.org/packages/d5/07/127e8b0bacfb325396196f9d976a22453049b89b9b2b08477cc3145faa44/propcache-0.5.2-cp314-cp314t-win32.whl", hash = "sha256:2d7aa89ebca5acc98cba9d1472d976e394782f587bad6661003602a619fd1821", size = 43813, upload-time = "2026-05-08T21:02:06.025Z" }, + { url = "https://files.pythonhosted.org/packages/88/fb/46dad6c0ae49ed230ab1b16c890c2b6314e2403e6c412976f4a72d64a527/propcache-0.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:d447bb0b3054be5818458fbb171208b1d9ff11eba14e18ca18b90cbb45767370", size = 47764, upload-time = "2026-05-08T21:02:07.353Z" }, + { url = "https://files.pythonhosted.org/packages/e7/c4/a47d0a63aa309d10d59ede6e9d4cff03a344a79d1f0f4cd0cd74997b53e0/propcache-0.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:fe67a3d11cd9b4efabfa45c3d00ffba2b26811442a73a581a94b67c2b5faccf6", size = 41140, upload-time = "2026-05-08T21:02:09.065Z" }, { url = "https://files.pythonhosted.org/packages/3a/ed/1cdcab6ba3d6ab7feca11fc14f0eeea80755bb53ef4e892079f31b10a25f/propcache-0.5.2-py3-none-any.whl", hash = "sha256:be1ddfcbb376e3de5d2e2db1d58d6d67463e6b4f9f040c000de8e300295465fe", size = 14036, upload-time = "2026-05-08T21:02:10.673Z" }, ] @@ -4587,6 +4581,12 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b8/b5/9182c9af3836cca61696dabe4fd1304e17bc56cb62f17439e1154f225dd3/psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312", size = 184062, upload-time = "2026-01-28T18:15:04.436Z" }, { url = "https://files.pythonhosted.org/packages/16/ba/0756dca669f5a9300d0cbcbfae9a4c30e446dfc7440ffe43ded5724bfd93/psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b", size = 139893, upload-time = "2026-01-28T18:15:06.378Z" }, { url = "https://files.pythonhosted.org/packages/1c/61/8fa0e26f33623b49949346de05ec1ddaad02ed8ba64af45f40a147dbfa97/psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9", size = 135589, upload-time = "2026-01-28T18:15:08.03Z" }, + { url = "https://files.pythonhosted.org/packages/81/69/ef179ab5ca24f32acc1dac0c247fd6a13b501fd5534dbae0e05a1c48b66d/psutil-7.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00", size = 130664, upload-time = "2026-01-28T18:15:09.469Z" }, + { url = "https://files.pythonhosted.org/packages/7b/64/665248b557a236d3fa9efc378d60d95ef56dd0a490c2cd37dafc7660d4a9/psutil-7.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9", size = 131087, upload-time = "2026-01-28T18:15:11.724Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2e/e6782744700d6759ebce3043dcfa661fb61e2fb752b91cdeae9af12c2178/psutil-7.2.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a", size = 182383, upload-time = "2026-01-28T18:15:13.445Z" }, + { url = "https://files.pythonhosted.org/packages/57/49/0a41cefd10cb7505cdc04dab3eacf24c0c2cb158a998b8c7b1d27ee2c1f5/psutil-7.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf", size = 185210, upload-time = "2026-01-28T18:15:16.002Z" }, + { url = "https://files.pythonhosted.org/packages/dd/2c/ff9bfb544f283ba5f83ba725a3c5fec6d6b10b8f27ac1dc641c473dc390d/psutil-7.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1", size = 141228, upload-time = "2026-01-28T18:15:18.385Z" }, + { url = "https://files.pythonhosted.org/packages/f2/fc/f8d9c31db14fcec13748d373e668bc3bed94d9077dbc17fb0eebc073233c/psutil-7.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841", size = 136284, upload-time = "2026-01-28T18:15:19.912Z" }, { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" }, { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" }, { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" }, @@ -4597,36 +4597,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" }, ] -[[package]] -name = "psycopg2-binary" -version = "2.9.12" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/2a/60/a3624f79acea344c16fbef3a94d28b89a8042ddfb8f3e4ca83f538671409/psycopg2_binary-2.9.12.tar.gz", hash = "sha256:5ac9444edc768c02a6b6a591f070b8aae28ff3a99be57560ac996001580f294c", size = 379686, upload-time = "2026-04-21T09:40:34.304Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e2/9f/ef4ef3c8e15083df90ca35265cfd1a081a2f0cc07bb229c6314c6af817f4/psycopg2_binary-2.9.12-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5cdc05117180c5fa9c40eea8ea559ce64d73824c39d928b7da9fb5f6a9392433", size = 3712459, upload-time = "2026-04-20T23:34:30.549Z" }, - { url = "https://files.pythonhosted.org/packages/b5/01/3dd14e46ba48c1e1a6ec58ee599fa1b5efa00c246d5046cd903d0eeb1af1/psycopg2_binary-2.9.12-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d3227a3bc228c10d21011a99245edca923e4e8bf461857e869a507d9a41fe9f6", size = 3822936, upload-time = "2026-04-20T23:34:32.77Z" }, - { url = "https://files.pythonhosted.org/packages/a6/f7/0640e4901119d8a9f7a1784b927f494e2198e213ceb593753d1f2c8b1b30/psycopg2_binary-2.9.12-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:995ce929eede89db6254b50827e2b7fd61e50d11f0b116b29fffe4a2e53c4580", size = 4578676, upload-time = "2026-04-20T23:34:35.18Z" }, - { url = "https://files.pythonhosted.org/packages/b0/55/44df3965b5f297c50cc0b1b594a31c67d6127a9d133045b8a66611b14dfb/psycopg2_binary-2.9.12-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9fe06d93e72f1c048e731a2e3e7854a5bfaa58fc736068df90b352cefe66f03f", size = 4274917, upload-time = "2026-04-20T23:34:37.982Z" }, - { url = "https://files.pythonhosted.org/packages/b0/4b/74535248b1eac0c9336862e8617c765ac94dac76f9e25d7c4a79588c8907/psycopg2_binary-2.9.12-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40e7b28b63aaf737cb3a1edc3a9bbc9a9f4ad3dcb7152e8c1130e4050eddcb7d", size = 5894843, upload-time = "2026-04-20T23:34:40.856Z" }, - { url = "https://files.pythonhosted.org/packages/f2/ba/f1bf8d2ae71868ad800b661099086ee52bc0f8d9f05be1acd8ebb06757cc/psycopg2_binary-2.9.12-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:89d19a9f7899e8eb0656a2b3a08e0da04c720a06db6e0033eab5928aabe60fa9", size = 4110556, upload-time = "2026-04-20T23:34:44.016Z" }, - { url = "https://files.pythonhosted.org/packages/45/46/c15706c338403b7c420bcc0c2905aad116cc064545686d8bf85f1999ea00/psycopg2_binary-2.9.12-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:612b965daee295ae2da8f8218ce1d274645dc76ef3f1abf6a0a94fd57eff876d", size = 3655714, upload-time = "2026-04-20T23:34:46.233Z" }, - { url = "https://files.pythonhosted.org/packages/b3/7c/a2d5dc09b64a4564db242a0fe418fde7d33f6f8259dd2c5b9d7def00fb5a/psycopg2_binary-2.9.12-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b9a339b79d37c1b45f3235265f07cdeb0cb5ad7acd2ac7720a5920989c17c24e", size = 3301154, upload-time = "2026-04-20T23:34:49.528Z" }, - { url = "https://files.pythonhosted.org/packages/c0/e8/cc8c9a4ce71461f9ec548d38cadc41dc184b34c73e6455450775a9334ccd/psycopg2_binary-2.9.12-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:3471336e1acfd9c7fe507b8bad5af9317b6a89294f9eb37bd9a030bb7bebcdc6", size = 3048882, upload-time = "2026-04-20T23:34:51.86Z" }, - { url = "https://files.pythonhosted.org/packages/19/6a/31e2296bc0787c5ab75d3d118e40b239db8151b5192b90b77c72bc9256e9/psycopg2_binary-2.9.12-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7af18183109e23502c8b2ae7f6926c0882766f35b5175a4cd737ad825e4d7a1b", size = 3351298, upload-time = "2026-04-20T23:34:54.124Z" }, - { url = "https://files.pythonhosted.org/packages/5f/a8/75f4e3e11203b590150abed2cf7794b9c9c9f7eceddae955191138b44dde/psycopg2_binary-2.9.12-cp312-cp312-win_amd64.whl", hash = "sha256:398fcd4db988c7d7d3713e2b8e18939776fd3fb447052daae4f24fa39daede4c", size = 2757230, upload-time = "2026-04-20T23:34:56.242Z" }, - { url = "https://files.pythonhosted.org/packages/91/bb/4608c96f970f6e0c56572e87027ef4404f709382a3503e9934526d7ba051/psycopg2_binary-2.9.12-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7c729a73c7b1b84de3582f73cdd27d905121dc2c531f3d9a3c32a3011033b965", size = 3712419, upload-time = "2026-04-20T23:34:58.754Z" }, - { url = "https://files.pythonhosted.org/packages/5e/af/48f76af9d50d61cf390f8cd657b503168b089e2e9298e48465d029fcc713/psycopg2_binary-2.9.12-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4413d0caef93c5cf50b96863df4c2efe8c269bf2267df353225595e7e15e8df7", size = 3822990, upload-time = "2026-04-20T23:35:00.821Z" }, - { url = "https://files.pythonhosted.org/packages/7a/df/aba0f99397cd811d32e06fc0cc781f1f3ce98bc0e729cb423925085d781a/psycopg2_binary-2.9.12-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:4dfcf8e45ebb0c663be34a3442f65e17311f3367089cd4e5e3a3e8e62c978777", size = 4578696, upload-time = "2026-04-20T23:35:03.409Z" }, - { url = "https://files.pythonhosted.org/packages/95/9c/eaa74021ac4e4d5c2f83d82fc6615a63f4fe6c94dc4e94c3990427053f67/psycopg2_binary-2.9.12-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c41321a14dd74aceb6a9a643b9253a334521babfa763fa873e33d89cfa122fb5", size = 4274982, upload-time = "2026-04-20T23:35:05.583Z" }, - { url = "https://files.pythonhosted.org/packages/35/ed/c25deff98bd26187ba48b3b250a3ffc3037c46c5b89362534a15d200e0db/psycopg2_binary-2.9.12-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:83946ba43979ebfdc99a3cd0ee775c89f221df026984ba19d46133d8d75d3cd9", size = 5894867, upload-time = "2026-04-20T23:35:07.902Z" }, - { url = "https://files.pythonhosted.org/packages/9a/81/8d0e21ca77373c6c9589e5c4528f6e8f0c08c62cafc76fb0bddb7a2cee22/psycopg2_binary-2.9.12-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:411e85815652d13560fbe731878daa5d92378c4995a22302071890ec3397d019", size = 4110578, upload-time = "2026-04-20T23:35:10.149Z" }, - { url = "https://files.pythonhosted.org/packages/00/fc/f481e2435bd8f742d0123309174aae4165160ad3ef17c1b99c3622c241d2/psycopg2_binary-2.9.12-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1c8ad4c08e00f7679559eaed7aff1edfffc60c086b976f93972f686384a95e2c", size = 3655816, upload-time = "2026-04-20T23:35:12.56Z" }, - { url = "https://files.pythonhosted.org/packages/53/79/b9f46466bdbe9f239c96cde8be33c1aace4842f06013b47b730dc9759187/psycopg2_binary-2.9.12-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:00814e40fa23c2b37ef0a1e3c749d89982c73a9cb5046137f0752a22d432e82f", size = 3301307, upload-time = "2026-04-20T23:35:15.029Z" }, - { url = "https://files.pythonhosted.org/packages/3f/19/7dc003b32fe35024df89b658104f7c8538a8b2dcbde7a4e746ce929742e7/psycopg2_binary-2.9.12-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:98062447aebc20ed20add1f547a364fd0ef8933640d5372ff1873f8deb9b61be", size = 3048968, upload-time = "2026-04-20T23:35:16.757Z" }, - { url = "https://files.pythonhosted.org/packages/91/58/2dbd7db5c604d45f4950d988506aae672a14126ec22998ced5021cbb76bb/psycopg2_binary-2.9.12-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:66a7685d7e548f10fb4ce32fb01a7b7f4aa702134de92a292c7bd9e0d3dbd290", size = 3351369, upload-time = "2026-04-20T23:35:18.933Z" }, - { url = "https://files.pythonhosted.org/packages/42/ee/dee8dcaad07f735824de3d6563bc67119fa6c28257b17977a8d624f02fab/psycopg2_binary-2.9.12-cp313-cp313-win_amd64.whl", hash = "sha256:b6937f5fe4e180aeee87de907a2fa982ded6f7f15d7218f78a083e4e1d68f2a0", size = 2757347, upload-time = "2026-04-20T23:35:21.283Z" }, -] - [[package]] name = "psygnal" version = "0.15.1" @@ -4643,6 +4613,11 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/2d/4f/3593e5adb88a188c798604aed95fbc1479f30230e7f51e8f2c770e6a3832/psygnal-0.15.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e9fca977f5335deea39aed22e31d9795983e4f243e59a7d3c4105793adb7693d", size = 885616, upload-time = "2026-01-04T16:38:30.081Z" }, { url = "https://files.pythonhosted.org/packages/58/4c/14779ed4c3a1d71fa1a9a87ecfb184ad3335dd64681067f77c1c47b14ae9/psygnal-0.15.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0c85b7d05b92ccbec47c75ab8a5545eda462e81a492c82424aba5ab81a3ad89d", size = 876516, upload-time = "2026-01-04T16:38:31.422Z" }, { url = "https://files.pythonhosted.org/packages/3e/bc/4f771e3cdcde4db4023dbf36d6f0aab44e02b9de719353c22954b655e2ff/psygnal-0.15.1-cp313-cp313-win_amd64.whl", hash = "sha256:ac0e693b29e0a429e97315a52313321855bef6140e9975b7ae78b4d93c8fbb42", size = 419172, upload-time = "2026-01-04T16:38:32.82Z" }, + { url = "https://files.pythonhosted.org/packages/f4/2e/975bd61727578d88df62797f78390965ca7905780cf01eb59cb095a13638/psygnal-0.15.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:803fc33c4280c822c6f4b22e6c3ea7c4483e190f3cc69e69350098b3799476f3", size = 595706, upload-time = "2026-01-04T16:38:34.139Z" }, + { url = "https://files.pythonhosted.org/packages/b8/55/e487f1d91497eb75e86c3fdfef69a21b1cab24d023383dd7648b08797d6a/psygnal-0.15.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4f53b4b83355b0a785b745987fd04e59bbf169a9028ed81a68ca7e05fb76d458", size = 575133, upload-time = "2026-01-04T16:38:35.448Z" }, + { url = "https://files.pythonhosted.org/packages/bf/2f/f286355accd0e68d3eef52e63c8b9ab6ba33ec3107177719a036b3319657/psygnal-0.15.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bcbca12190f5aa65c1f8fb04a81fa6f4463c5f5dde25cd74c3a56ceff6f37b02", size = 889565, upload-time = "2026-01-04T16:38:37.003Z" }, + { url = "https://files.pythonhosted.org/packages/fc/dc/40c6026c88d7f9220ecc913afe0501045a512c9b82f9b7e036bb089dc287/psygnal-0.15.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1ac399566852fe4354ce26a1acbe12319232e8c2b615fe5ad1e114c547095cf6", size = 880863, upload-time = "2026-01-04T16:38:38.381Z" }, + { url = "https://files.pythonhosted.org/packages/b7/85/b4f45ec3057c473b5622fc002b3a636a698c34d3a0917a064ff5247f1984/psygnal-0.15.1-cp314-cp314-win_amd64.whl", hash = "sha256:d3a03055f331ce91d44581c71edb79938ccc133a94af2ce7ad3a18fa57ac7be5", size = 423654, upload-time = "2026-01-04T16:38:39.7Z" }, { url = "https://files.pythonhosted.org/packages/46/49/7742544684bee728ec123515d2694cee859aa2a705951a461230b00f18cc/psygnal-0.15.1-py3-none-any.whl", hash = "sha256:4221140e633e45b076953c64bcb9b41a744833527f9a037c1ca98bc270798cbf", size = 90638, upload-time = "2026-01-04T16:38:40.841Z" }, ] @@ -4699,30 +4674,45 @@ wheels = [ [[package]] name = "pyarrow" -version = "19.0.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/7f/09/a9046344212690f0632b9c709f9bf18506522feb333c894d0de81d62341a/pyarrow-19.0.1.tar.gz", hash = "sha256:3bf266b485df66a400f282ac0b6d1b500b9d2ae73314a153dbe97d6d5cc8a99e", size = 1129437, upload-time = "2025-02-18T18:55:57.027Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/78/b4/94e828704b050e723f67d67c3535cf7076c7432cd4cf046e4bb3b96a9c9d/pyarrow-19.0.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:80b2ad2b193e7d19e81008a96e313fbd53157945c7be9ac65f44f8937a55427b", size = 30670749, upload-time = "2025-02-18T18:53:00.062Z" }, - { url = "https://files.pythonhosted.org/packages/7e/3b/4692965e04bb1df55e2c314c4296f1eb12b4f3052d4cf43d29e076aedf66/pyarrow-19.0.1-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:ee8dec072569f43835932a3b10c55973593abc00936c202707a4ad06af7cb294", size = 32128007, upload-time = "2025-02-18T18:53:06.581Z" }, - { url = "https://files.pythonhosted.org/packages/22/f7/2239af706252c6582a5635c35caa17cb4d401cd74a87821ef702e3888957/pyarrow-19.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4d5d1ec7ec5324b98887bdc006f4d2ce534e10e60f7ad995e7875ffa0ff9cb14", size = 41144566, upload-time = "2025-02-18T18:53:11.958Z" }, - { url = "https://files.pythonhosted.org/packages/fb/e3/c9661b2b2849cfefddd9fd65b64e093594b231b472de08ff658f76c732b2/pyarrow-19.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3ad4c0eb4e2a9aeb990af6c09e6fa0b195c8c0e7b272ecc8d4d2b6574809d34", size = 42202991, upload-time = "2025-02-18T18:53:17.678Z" }, - { url = "https://files.pythonhosted.org/packages/fe/4f/a2c0ed309167ef436674782dfee4a124570ba64299c551e38d3fdaf0a17b/pyarrow-19.0.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:d383591f3dcbe545f6cc62daaef9c7cdfe0dff0fb9e1c8121101cabe9098cfa6", size = 40507986, upload-time = "2025-02-18T18:53:26.263Z" }, - { url = "https://files.pythonhosted.org/packages/27/2e/29bb28a7102a6f71026a9d70d1d61df926887e36ec797f2e6acfd2dd3867/pyarrow-19.0.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:b4c4156a625f1e35d6c0b2132635a237708944eb41df5fbe7d50f20d20c17832", size = 42087026, upload-time = "2025-02-18T18:53:33.063Z" }, - { url = "https://files.pythonhosted.org/packages/16/33/2a67c0f783251106aeeee516f4806161e7b481f7d744d0d643d2f30230a5/pyarrow-19.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:5bd1618ae5e5476b7654c7b55a6364ae87686d4724538c24185bbb2952679960", size = 25250108, upload-time = "2025-02-18T18:53:38.462Z" }, - { url = "https://files.pythonhosted.org/packages/2b/8d/275c58d4b00781bd36579501a259eacc5c6dfb369be4ddeb672ceb551d2d/pyarrow-19.0.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:e45274b20e524ae5c39d7fc1ca2aa923aab494776d2d4b316b49ec7572ca324c", size = 30653552, upload-time = "2025-02-18T18:53:44.357Z" }, - { url = "https://files.pythonhosted.org/packages/a0/9e/e6aca5cc4ef0c7aec5f8db93feb0bde08dbad8c56b9014216205d271101b/pyarrow-19.0.1-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:d9dedeaf19097a143ed6da37f04f4051aba353c95ef507764d344229b2b740ae", size = 32103413, upload-time = "2025-02-18T18:53:52.971Z" }, - { url = "https://files.pythonhosted.org/packages/6a/fa/a7033f66e5d4f1308c7eb0dfcd2ccd70f881724eb6fd1776657fdf65458f/pyarrow-19.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ebfb5171bb5f4a52319344ebbbecc731af3f021e49318c74f33d520d31ae0c4", size = 41134869, upload-time = "2025-02-18T18:53:59.471Z" }, - { url = "https://files.pythonhosted.org/packages/2d/92/34d2569be8e7abdc9d145c98dc410db0071ac579b92ebc30da35f500d630/pyarrow-19.0.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f2a21d39fbdb948857f67eacb5bbaaf36802de044ec36fbef7a1c8f0dd3a4ab2", size = 42192626, upload-time = "2025-02-18T18:54:06.062Z" }, - { url = "https://files.pythonhosted.org/packages/0a/1f/80c617b1084fc833804dc3309aa9d8daacd46f9ec8d736df733f15aebe2c/pyarrow-19.0.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:99bc1bec6d234359743b01e70d4310d0ab240c3d6b0da7e2a93663b0158616f6", size = 40496708, upload-time = "2025-02-18T18:54:12.347Z" }, - { url = "https://files.pythonhosted.org/packages/e6/90/83698fcecf939a611c8d9a78e38e7fed7792dcc4317e29e72cf8135526fb/pyarrow-19.0.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:1b93ef2c93e77c442c979b0d596af45e4665d8b96da598db145b0fec014b9136", size = 42075728, upload-time = "2025-02-18T18:54:19.364Z" }, - { url = "https://files.pythonhosted.org/packages/40/49/2325f5c9e7a1c125c01ba0c509d400b152c972a47958768e4e35e04d13d8/pyarrow-19.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:d9d46e06846a41ba906ab25302cf0fd522f81aa2a85a71021826f34639ad31ef", size = 25242568, upload-time = "2025-02-18T18:54:25.846Z" }, - { url = "https://files.pythonhosted.org/packages/3f/72/135088d995a759d4d916ec4824cb19e066585b4909ebad4ab196177aa825/pyarrow-19.0.1-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:c0fe3dbbf054a00d1f162fda94ce236a899ca01123a798c561ba307ca38af5f0", size = 30702371, upload-time = "2025-02-18T18:54:30.665Z" }, - { url = "https://files.pythonhosted.org/packages/2e/01/00beeebd33d6bac701f20816a29d2018eba463616bbc07397fdf99ac4ce3/pyarrow-19.0.1-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:96606c3ba57944d128e8a8399da4812f56c7f61de8c647e3470b417f795d0ef9", size = 32116046, upload-time = "2025-02-18T18:54:35.995Z" }, - { url = "https://files.pythonhosted.org/packages/1f/c9/23b1ea718dfe967cbd986d16cf2a31fe59d015874258baae16d7ea0ccabc/pyarrow-19.0.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f04d49a6b64cf24719c080b3c2029a3a5b16417fd5fd7c4041f94233af732f3", size = 41091183, upload-time = "2025-02-18T18:54:42.662Z" }, - { url = "https://files.pythonhosted.org/packages/3a/d4/b4a3aa781a2c715520aa8ab4fe2e7fa49d33a1d4e71c8fc6ab7b5de7a3f8/pyarrow-19.0.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5a9137cf7e1640dce4c190551ee69d478f7121b5c6f323553b319cac936395f6", size = 42171896, upload-time = "2025-02-18T18:54:49.808Z" }, - { url = "https://files.pythonhosted.org/packages/23/1b/716d4cd5a3cbc387c6e6745d2704c4b46654ba2668260d25c402626c5ddb/pyarrow-19.0.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:7c1bca1897c28013db5e4c83944a2ab53231f541b9e0c3f4791206d0c0de389a", size = 40464851, upload-time = "2025-02-18T18:54:57.073Z" }, - { url = "https://files.pythonhosted.org/packages/ed/bd/54907846383dcc7ee28772d7e646f6c34276a17da740002a5cefe90f04f7/pyarrow-19.0.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:58d9397b2e273ef76264b45531e9d552d8ec8a6688b7390b5be44c02a37aade8", size = 42085744, upload-time = "2025-02-18T18:55:08.562Z" }, +version = "24.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/91/13/13e1069b351bdc3881266e11147ffccf687505dbb0ea74036237f5d454a5/pyarrow-24.0.0.tar.gz", hash = "sha256:85fe721a14dd823aca09127acbb06c3ca723efbd436c004f16bca601b04dcc83", size = 1180261, upload-time = "2026-04-21T10:51:25.837Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b4/a9/9686d9f07837f91f775e8932659192e02c74f9d8920524b480b85212cc68/pyarrow-24.0.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:6233c9ed9ab9d1db47de57d9753256d9dcffbf42db341576099f0fd9f6bf4810", size = 34981559, upload-time = "2026-04-21T10:47:22.17Z" }, + { url = "https://files.pythonhosted.org/packages/80/b6/0ddf0e9b6ead3474ab087ae598c76b031fc45532bf6a63f3a553440fb258/pyarrow-24.0.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:f7616236ec1bc2b15bfdec22a71ab38851c86f8f05ff64f379e1278cf20c634a", size = 36663654, upload-time = "2026-04-21T10:47:28.315Z" }, + { url = "https://files.pythonhosted.org/packages/7c/3b/926382efe8ce27ba729071d3566ade6dfb86bdf112f366000196b2f5780a/pyarrow-24.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:1617043b99bd33e5318ae18eb2919af09c71322ef1ca46566cdafc6e6712fb66", size = 45679394, upload-time = "2026-04-21T10:47:34.821Z" }, + { url = "https://files.pythonhosted.org/packages/b3/7a/829f7d9dfd37c207206081d6dad474d81dde29952401f07f2ba507814818/pyarrow-24.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:6165461f55ef6314f026de6638d661188e3455d3ec49834556a0ebbdbace18bb", size = 48863122, upload-time = "2026-04-21T10:47:42.056Z" }, + { url = "https://files.pythonhosted.org/packages/5f/e8/f88ce625fe8babaae64e8db2d417c7653adb3019b08aae85c5ed787dc816/pyarrow-24.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3b13dedfe76a0ad2d1d859b0811b53827a4e9d93a0bcb05cf59333ab4980cc7e", size = 49376032, upload-time = "2026-04-21T10:47:48.967Z" }, + { url = "https://files.pythonhosted.org/packages/36/7a/82c363caa145fff88fb475da50d3bf52bb024f61917be5424c3392eaf878/pyarrow-24.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:25ea65d868eb04015cd18e6df2fbe98f07e5bda2abefabcb88fce39a947716f6", size = 51929490, upload-time = "2026-04-21T10:47:55.981Z" }, + { url = "https://files.pythonhosted.org/packages/66/1c/e3e72c8014ad2743ca64a701652c733cc5cbcee15c0463a32a8c55518d9e/pyarrow-24.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:295f0a7f2e242dabd513737cf076007dc5b2d59237e3eca37b05c0c6446f3826", size = 27355660, upload-time = "2026-04-21T10:48:01.718Z" }, + { url = "https://files.pythonhosted.org/packages/6f/d3/a1abf004482026ddc17f4503db227787fa3cfe41ec5091ff20e4fea55e57/pyarrow-24.0.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:02b001b3ed4723caa44f6cd1af2d5c86aa2cf9971dacc2ffa55b21237713dfba", size = 34976759, upload-time = "2026-04-21T10:48:07.258Z" }, + { url = "https://files.pythonhosted.org/packages/4f/4a/34f0a36d28a2dd32225301b79daad44e243dc1a2bb77d43b60749be255c4/pyarrow-24.0.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:04920d6a71aabd08a0417709efce97d45ea8e6fb733d9ca9ecffb13c67839f68", size = 36658471, upload-time = "2026-04-21T10:48:13.347Z" }, + { url = "https://files.pythonhosted.org/packages/1f/78/543b94712ae8bb1a6023bcc1acf1a740fbff8286747c289cd9468fced2a5/pyarrow-24.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:a964266397740257f16f7bb2e4f08a0c81454004beab8ff59dd531b73610e9f2", size = 45675981, upload-time = "2026-04-21T10:48:20.201Z" }, + { url = "https://files.pythonhosted.org/packages/84/9f/8fb7c222b100d314137fa40ec050de56cd8c6d957d1cfff685ce72f15b17/pyarrow-24.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:6f066b179d68c413374294bc1735f68475457c933258df594443bb9d88ddc2a0", size = 48859172, upload-time = "2026-04-21T10:48:27.541Z" }, + { url = "https://files.pythonhosted.org/packages/a7/d3/1ea72538e6c8b3b475ed78d1049a2c518e655761ea50fe1171fc855fcab7/pyarrow-24.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1183baeb14c5f587b1ec52831e665718ce632caab84b7cd6b85fd44f96114495", size = 49385733, upload-time = "2026-04-21T10:48:34.7Z" }, + { url = "https://files.pythonhosted.org/packages/c3/be/c3d8b06a1ba35f2260f8e1f771abbee7d5e345c0937aab90675706b1690a/pyarrow-24.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:806f24b4085453c197a5078218d1ee08783ebbba271badd153d1ae22a3ee804f", size = 51934335, upload-time = "2026-04-21T10:48:42.099Z" }, + { url = "https://files.pythonhosted.org/packages/9c/62/89e07a1e7329d2cde3e3c6994ba0839a24977a2beda8be6005ea3d860b99/pyarrow-24.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:e4505fc6583f7b05ab854934896bcac8253b04ac1171a77dfb73efef92076d91", size = 27271748, upload-time = "2026-04-21T10:49:42.532Z" }, + { url = "https://files.pythonhosted.org/packages/17/1a/cff3a59f80b5b1658549d46611b67163f65e0664431c076ad728bf9d5af4/pyarrow-24.0.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:1a4e45017efbf115032e4475ee876d525e0e36c742214fbe405332480ecd6275", size = 35238554, upload-time = "2026-04-21T10:48:48.526Z" }, + { url = "https://files.pythonhosted.org/packages/a8/99/cce0f42a327bfef2c420fb6078a3eb834826e5d6697bf3009fe11d2ad051/pyarrow-24.0.0-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:7986f1fa71cee060ad00758bcc79d3a93bab8559bf978fab9e53472a2e25a17b", size = 36782301, upload-time = "2026-04-21T10:48:55.181Z" }, + { url = "https://files.pythonhosted.org/packages/2a/66/8e560d5ff6793ca29aca213c53eec0dd482dd46cb93b2819e5aab52e4252/pyarrow-24.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:d3e0b61e8efb24ed38898e5cdc5fffa9124be480008d401a1f8071500494ae42", size = 45721929, upload-time = "2026-04-21T10:49:03.676Z" }, + { url = "https://files.pythonhosted.org/packages/27/0c/a26e25505d030716e078d9f16eb74973cbf0b33b672884e9f9da1c83b871/pyarrow-24.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:55a3bc1e3df3b5567b7d27ef551b2283f0c68a5e86f1cd56abc569da4f31335b", size = 48825365, upload-time = "2026-04-21T10:49:11.714Z" }, + { url = "https://files.pythonhosted.org/packages/5f/eb/771f9ecb0c65e73fe9dccdd1717901b9594f08c4515d000c7c62df573811/pyarrow-24.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:641f795b361874ac9da5294f8f443dfdbee355cf2bd9e3b8d97aaac2306b9b37", size = 49451819, upload-time = "2026-04-21T10:49:21.474Z" }, + { url = "https://files.pythonhosted.org/packages/48/da/61ae89a88732f5a785646f3ec6125dbb640fa98a540eb2b9889caa561403/pyarrow-24.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8adc8e6ce5fccf5dc707046ae4914fd537def529709cc0d285d37a7f9cd442ca", size = 51909252, upload-time = "2026-04-21T10:49:31.164Z" }, + { url = "https://files.pythonhosted.org/packages/cb/1a/8dd5cafab7b66573fa91c03d06d213356ad4edd71813aa75e08ce2b3a844/pyarrow-24.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:9b18371ad2f44044b81a8d23bc2d8a9b6a6226dca775e8e16cfee640473d6c5d", size = 27388127, upload-time = "2026-04-21T10:49:37.334Z" }, + { url = "https://files.pythonhosted.org/packages/ad/80/d022a34ff05d2cbedd8ccf841fc1f532ecfa9eb5ed1711b56d0e0ea71fc9/pyarrow-24.0.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:1cc9057f0319e26333b357e17f3c2c022f1a83739b48a88b25bfd5fa2dc18838", size = 35007997, upload-time = "2026-04-21T10:49:48.796Z" }, + { url = "https://files.pythonhosted.org/packages/1a/ff/f01485fda6f4e5d441afb8dd5e7681e4db18826c1e271852f5d3957d6a80/pyarrow-24.0.0-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:e6f1278ee4785b6db21229374a1c9e54ec7c549de5d1efc9630b6207de7e170b", size = 36678720, upload-time = "2026-04-21T10:49:55.858Z" }, + { url = "https://files.pythonhosted.org/packages/9e/c2/2d2d5fea814237923f71b36495211f20b43a1576f9a4d6da7e751a64ec6f/pyarrow-24.0.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:adbbedc55506cbdabb830890444fb856bfb0060c46c6f8026c6c2f2cf86ae795", size = 45741852, upload-time = "2026-04-21T10:50:04.624Z" }, + { url = "https://files.pythonhosted.org/packages/8e/3a/28ba9c1c1ebdbb5f1b94dfebb46f207e52e6a554b7fe4132540fde29a3a0/pyarrow-24.0.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:ae8a1145af31d903fa9bb166824d7abe9b4681a000b0159c9fb99c11bc11ad26", size = 48889852, upload-time = "2026-04-21T10:50:12.293Z" }, + { url = "https://files.pythonhosted.org/packages/df/51/4a389acfd31dca009f8fb82d7f510bb4130f2b3a8e18cf00194d0687d8ac/pyarrow-24.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d7027eba1df3b2069e2e8d80f644fa0918b68c46432af3d088ddd390d063ecde", size = 49445207, upload-time = "2026-04-21T10:50:20.677Z" }, + { url = "https://files.pythonhosted.org/packages/19/4b/0bab2b23d2ae901b1b9a03c0efd4b2d070256f8ce3fc43f6e58c167b2081/pyarrow-24.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e56a1ffe9bf7b727432b89104cc0849c21582949dd7bdcb34f17b2001a351a76", size = 51954117, upload-time = "2026-04-21T10:50:29.14Z" }, + { url = "https://files.pythonhosted.org/packages/29/88/f4e9145da0417b3d2c12035a8492b35ff4a3dbc653e614fcfb51d9dedb38/pyarrow-24.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:38be1808cdd068605b787e6ca9119b27eb275a0234e50212c3492331680c3b1e", size = 28001155, upload-time = "2026-04-21T10:51:22.337Z" }, + { url = "https://files.pythonhosted.org/packages/79/4f/46a49a63f43526da895b1a45bbb51d5baf8e4d77159f8528fc3e5490007f/pyarrow-24.0.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:418e48ce50a45a6a6c73c454677203a9c75c966cb1e92ca3370959185f197a05", size = 35250387, upload-time = "2026-04-21T10:50:35.552Z" }, + { url = "https://files.pythonhosted.org/packages/a0/da/d5e0cd5ef00796922404806d5f00325cdadc3441ce2c13fe7115f2df9a64/pyarrow-24.0.0-cp314-cp314t-macosx_12_0_x86_64.whl", hash = "sha256:2f16197705a230a78270cdd4ea8a1d57e86b2fdcbc34a1f6aebc72e65c986f9a", size = 36797102, upload-time = "2026-04-21T10:50:42.417Z" }, + { url = "https://files.pythonhosted.org/packages/34/c7/5904145b0a593a05236c882933d439b5720f0a145381179063722fbfc123/pyarrow-24.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:fb24ac194bfc5e86839d7dcd52092ee31e5fe6733fe11f5e3b06ef0812b20072", size = 45745118, upload-time = "2026-04-21T10:50:49.324Z" }, + { url = "https://files.pythonhosted.org/packages/13/d3/cca42fe166d1c6e4d5b80e530b7949104d10e17508a90ae202dac205ce2a/pyarrow-24.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:9700ebd9a51f5895ce75ff4ac4b3c47a7d4b42bc618be8e713e5d56bacf5f931", size = 48844765, upload-time = "2026-04-21T10:50:55.579Z" }, + { url = "https://files.pythonhosted.org/packages/b0/49/942c3b79878ba928324d1e17c274ed84581db8c0a749b24bcf4cbdf15bd3/pyarrow-24.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d8ddd2768da81d3ee08cfea9b597f4abb4e8e1dc8ae7e204b608d23a0d3ab699", size = 49471890, upload-time = "2026-04-21T10:51:02.439Z" }, + { url = "https://files.pythonhosted.org/packages/76/97/ff71431000a75d84135a1ace5ca4ba11726a231a8007bbb320a4c54075d5/pyarrow-24.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:61a3d7eaa97a14768b542f3d284dc6400dd2470d9f080708b13cd46b6ae18136", size = 51932250, upload-time = "2026-04-21T10:51:10.576Z" }, + { url = "https://files.pythonhosted.org/packages/51/be/6f79d55816d5c22557cf27533543d5d70dfe692adfbee4b99f2760674f38/pyarrow-24.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:c91d00057f23b8d353039520dc3a6c09d8608164c692e9f59a175a42b2ae0c19", size = 28131282, upload-time = "2026-04-21T10:51:16.815Z" }, ] [[package]] @@ -4748,18 +4738,13 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e4/ff/30cfe8142470da3e45abe43a9842449ca0180d993320559890e2be19e4a5/pycocotools-2.0.11-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:368244f30eb8d6cae7003aa2c0831fbdf0153664a32859ec7fbceea52bfb6878", size = 474658, upload-time = "2025-12-15T22:31:24.883Z" }, { url = "https://files.pythonhosted.org/packages/bc/62/254ca92604106c7a5af3258e589e465e681fe0166f9b10f97d8ca70934d6/pycocotools-2.0.11-cp313-cp313t-win_amd64.whl", hash = "sha256:ac8aa17263e6489aa521f9fa91e959dfe0ea3a5519fde2cbf547312cdce7559e", size = 89681, upload-time = "2025-12-15T22:31:26.025Z" }, { url = "https://files.pythonhosted.org/packages/6e/f0/c019314dc122ad5e6281de420adc105abe9b59d00008f72ef3ad32b1e328/pycocotools-2.0.11-cp313-cp313t-win_arm64.whl", hash = "sha256:04480330df5013f6edd94891a0ee8294274185f1b5093d1b0f23d51778f0c0e9", size = 70520, upload-time = "2025-12-15T22:31:26.999Z" }, -] - -[[package]] -name = "pyconify" -version = "0.2.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "requests" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/fd/7f/94d424dc756a6287271cf40cf1b2a44c10e3f137bf3246a2b4a7416ca3d3/pyconify-0.2.1.tar.gz", hash = "sha256:8dd53757d9fbed41711434460932b2b5dbc25da720cd9f9a44af0187b2dfc07d", size = 22478, upload-time = "2025-02-06T13:20:53.592Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/72/40/50dd2e8bfec81676e4619903bd452c10dc0d8efac1533e79e67cc76759b5/pyconify-0.2.1-py3-none-any.whl", hash = "sha256:d3b53eee1f8a2d60c1d135610f42e789774dbe71c6d8af68af0a21d3b3ec9eb7", size = 19459, upload-time = "2025-02-06T13:20:51.613Z" }, + { url = "https://files.pythonhosted.org/packages/66/2b/58b35c88f2086c043ff1c87bd8e7bf36f94e84f7b01a5e00b6f5fabb92a7/pycocotools-2.0.11-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:a6b13baf6bfcf881b6d6ac6e23c776f87a68304cd86e53d1d6b9afa31e363c4e", size = 169883, upload-time = "2025-12-15T22:31:28.233Z" }, + { url = "https://files.pythonhosted.org/packages/24/c0/b970eefb78746c8b4f8b3fa1b49d9f3ec4c5429ef3c5d4bbcc55abebe478/pycocotools-2.0.11-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78bae4a9de9d34c4759754a848dfb3306f9ef1c2fcb12164ffbd3d013d008321", size = 486894, upload-time = "2025-12-15T22:31:29.283Z" }, + { url = "https://files.pythonhosted.org/packages/5b/f7/db7436820a1948d96fa9764b6026103e808840979be01246049f2c1e7f94/pycocotools-2.0.11-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:83d896f4310379849dfcfa7893afb0ff21f4f3cdb04ab3f61b05dd98953dd0ad", size = 483249, upload-time = "2025-12-15T22:31:31.687Z" }, + { url = "https://files.pythonhosted.org/packages/1e/a6/a14a12c9f50c41998fdc0d31fd3755bcbce124bac9abb1d6b99d1853cafd/pycocotools-2.0.11-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:eebd723503a2eb2c8b285f56ea3be1d9f3875cd7c40d945358a428db94f14015", size = 469070, upload-time = "2025-12-15T22:31:32.821Z" }, + { url = "https://files.pythonhosted.org/packages/46/de/aa4f65ece3da8e89310a1be00cad0700170fd13f41a3aaae2712291269d5/pycocotools-2.0.11-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:bd7a1e19ef56a828a94bace673372071d334a9232cd32ae3cd48845a04d45c4f", size = 475589, upload-time = "2025-12-15T22:31:34.188Z" }, + { url = "https://files.pythonhosted.org/packages/44/6f/04a30df03ae6236b369b361df0c50531d173d03678978806aa2182e02d1e/pycocotools-2.0.11-cp314-cp314t-win_amd64.whl", hash = "sha256:63026e11a56211058d0e84e8263f74cbccd5e786fac18d83fd221ecb9819fcc7", size = 93863, upload-time = "2025-12-15T22:31:35.38Z" }, + { url = "https://files.pythonhosted.org/packages/da/05/8942b640d6307a21c3ede188e8c56f07bedf246fac0e501437dbda72a350/pycocotools-2.0.11-cp314-cp314t-win_arm64.whl", hash = "sha256:8cedb8ccb97ffe9ed2c8c259234fa69f4f1e8665afe3a02caf93f6ef2952c07f", size = 72038, upload-time = "2025-12-15T22:31:36.768Z" }, ] [[package]] @@ -4786,18 +4771,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fd/7b/122376b1fd3c62c1ed9dc80c931ace4844b3c55407b6fb2d199377c9736f/pydantic-2.13.4-py3-none-any.whl", hash = "sha256:45a282cde31d808236fd7ea9d919b128653c8b38b393d1c4ab335c62924d9aba", size = 472262, upload-time = "2026-05-06T13:43:02.641Z" }, ] -[[package]] -name = "pydantic-compat" -version = "0.1.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pydantic" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/9c/7e/43400b6e0800065a982efcfa3e87c8f8d247d60ea75ca1a9d01702e050f8/pydantic_compat-0.1.2.tar.gz", hash = "sha256:c5c5bca39ca2d22cad00c02898e400e1920e5127649a8e860637f15566739373", size = 12838, upload-time = "2023-10-24T23:25:09.544Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7f/65/2edf586ff7b3dfc520977c6529c9b718c86ef8459ece088f1ef1f74bf1d4/pydantic_compat-0.1.2-py3-none-any.whl", hash = "sha256:37a4df48565a35aedc947f0fde5edbdff270a30836d995923287292bb59d5677", size = 13092, upload-time = "2023-10-24T23:25:08.155Z" }, -] - [[package]] name = "pydantic-core" version = "2.46.4" @@ -4837,6 +4810,36 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/5b/24/b375a480d53113860c299764bfe9f349a3dc9108b3adc0d7f0d786492ebf/pydantic_core-2.46.4-cp313-cp313-win32.whl", hash = "sha256:9fa8ae11da9e2b3126c6426f147e0fba88d96d65921799bb30c6abd1cb2c97fb", size = 1973693, upload-time = "2026-05-06T13:37:55.072Z" }, { url = "https://files.pythonhosted.org/packages/7e/e8/cff247591966f2d22ec8c003cd7587e27b7ba7b81ab2fb888e3ab75dc285/pydantic_core-2.46.4-cp313-cp313-win_amd64.whl", hash = "sha256:6b3ace8194b0e5204818c92802dcdca7fc6d88aabbb799d7c795540d9cd6d292", size = 2071819, upload-time = "2026-05-06T13:38:49.139Z" }, { url = "https://files.pythonhosted.org/packages/c6/1a/f4aee670d5670e9e148e0c82c7db98d780be566c6e6a97ee8035528ca0b3/pydantic_core-2.46.4-cp313-cp313-win_arm64.whl", hash = "sha256:184c081504d17f1c1066e430e117142b2c77d9448a97f7b65c6ac9fd9aee238d", size = 2027411, upload-time = "2026-05-06T13:40:45.796Z" }, + { url = "https://files.pythonhosted.org/packages/8d/74/228a26ddad29c6672b805d9fd78e8d251cd04004fa7eed0e622096cd0250/pydantic_core-2.46.4-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:428e04521a40150c85216fc8b85e8d39fece235a9cf5e383761238c7fa9b96fb", size = 2102079, upload-time = "2026-05-06T13:38:41.019Z" }, + { url = "https://files.pythonhosted.org/packages/ad/1f/8970b150a4b4365623ae00fc88603491f763c627311ae8031e3111356d6e/pydantic_core-2.46.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23ace664830ee0bfe014a0c7bc248b1f7f25ed7ad103852c317624a1083af462", size = 1952179, upload-time = "2026-05-06T13:36:59.812Z" }, + { url = "https://files.pythonhosted.org/packages/95/30/5211a831ae054928054b2f79731661087a2bc5c01e825c672b3a4a8f1b3e/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce5c1d2a8b27468f433ca974829c44060b8097eedc39933e3c206a90ee49c4a9", size = 1978926, upload-time = "2026-05-06T13:37:39.933Z" }, + { url = "https://files.pythonhosted.org/packages/57/e9/689668733b1eb67adeef047db3c2e8788fcf65a7fd9c9e2b46b7744fe245/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7283d57845ecf5a163403eb0702dfc220cc4fbdd18919cb5ccea4f95ee1cdab4", size = 2046785, upload-time = "2026-05-06T13:38:01.995Z" }, + { url = "https://files.pythonhosted.org/packages/60/d9/6715260422ff50a2109878fd24d948a6c3446bb2664f34ee78cd972b3acd/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8daafc69c93ee8a0204506a3b6b30f586ef54028f52aeeeb5c4cfc5184fd5914", size = 2228733, upload-time = "2026-05-06T13:40:50.371Z" }, + { url = "https://files.pythonhosted.org/packages/18/ae/fdb2f64316afca925640f8e70bb1a564b0ec2721c1389e25b8eb4bf9a299/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd2213145bcc2ba85884d0ac63d222fece9209678f77b9b4d76f054c561adb28", size = 2307534, upload-time = "2026-05-06T13:37:21.531Z" }, + { url = "https://files.pythonhosted.org/packages/89/1d/8eff589b45bb8190a9d12c49cfad0f176a5cbd1534908a6b5125e2886239/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a5f930472650a82629163023e630d160863fce524c616f4e5186e5de9d9a49b", size = 2099732, upload-time = "2026-05-06T13:39:31.942Z" }, + { url = "https://files.pythonhosted.org/packages/06/d5/ee5a3366637fee41dee51a1fc91562dcf12ddbc68fda34e6b253da2324bb/pydantic_core-2.46.4-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:c1b3f518abeca3aa13c712fd202306e145abf59a18b094a6bafb2d2bbf59192c", size = 2129627, upload-time = "2026-05-06T13:37:25.033Z" }, + { url = "https://files.pythonhosted.org/packages/94/33/2414be571d2c6a6c4d08be21f9292b6d3fdb08949a97b6dfe985017821db/pydantic_core-2.46.4-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1a7dd0b3ee80d90150e3495a3a13ac34dbcbfd4f012996a6a1d8900e91b5c0fb", size = 2179141, upload-time = "2026-05-06T13:37:14.046Z" }, + { url = "https://files.pythonhosted.org/packages/7b/79/7daa95be995be0eecc4cf75064cb33f9bbbfe3fe0158caf2f0d4a996a5c7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:3fb702cd90b0446a3a1c5e470bfa0dd23c0233b676a9099ddcc964fa6ca13898", size = 2184325, upload-time = "2026-05-06T13:36:53.615Z" }, + { url = "https://files.pythonhosted.org/packages/9f/cb/d0a382f5c0de8a222dc61c65348e0ce831b1f68e0a018450d31c2cace3a5/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:b8458003118a712e66286df6a707db01c52c0f52f7db8e4a38f0da1d3b94fc4e", size = 2323990, upload-time = "2026-05-06T13:40:29.971Z" }, + { url = "https://files.pythonhosted.org/packages/05/db/d9ba624cc4a5aced1598e88c04fdbd8310c8a69b9d38b9a3d39ce3a61ed7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:372429a130e469c9cd698925ce5fc50940b7a1336b0d82038e63d5bbc4edc519", size = 2369978, upload-time = "2026-05-06T13:37:23.027Z" }, + { url = "https://files.pythonhosted.org/packages/f2/20/d15df15ba918c423461905802bfd2981c3af0bfa0e40d05e13edbfa48bc3/pydantic_core-2.46.4-cp314-cp314-win32.whl", hash = "sha256:85bb3611ff1802f3ee7fdd7dbff26b56f343fb432d57a4728fdd49b6ef35e2f4", size = 1966354, upload-time = "2026-05-06T13:38:03.499Z" }, + { url = "https://files.pythonhosted.org/packages/fc/b6/6b8de4c0a7d7ab3004c439c80c5c1e0a3e8d78bbae19379b01960383d9e5/pydantic_core-2.46.4-cp314-cp314-win_amd64.whl", hash = "sha256:811ff8e9c313ab425368bcbb36e5c4ebd7108c2bbf4e4089cfbb0b01eff63fac", size = 2072238, upload-time = "2026-05-06T13:39:40.807Z" }, + { url = "https://files.pythonhosted.org/packages/32/36/51eb763beec1f4cf59b1db243a7dcc39cbb41230f050a09b9d69faaf0a48/pydantic_core-2.46.4-cp314-cp314-win_arm64.whl", hash = "sha256:bfec22eab3c8cc2ceec0248aec886624116dc079afa027ecc8ad4a7e62010f8a", size = 2018251, upload-time = "2026-05-06T13:37:26.72Z" }, + { url = "https://files.pythonhosted.org/packages/e8/91/855af51d625b23aa987116a19e231d2aaef9c4a415273ddc189b79a45fee/pydantic_core-2.46.4-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:af8244b2bef6aaad6d92cda81372de7f8c8d36c9f0c3ea36e827c60e7d9467a0", size = 2099593, upload-time = "2026-05-06T13:39:47.682Z" }, + { url = "https://files.pythonhosted.org/packages/fb/1b/8784a54c65edb5f49f0a14d6977cf1b209bba85a4c77445b255c2de58ab3/pydantic_core-2.46.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a4330cdbc57162e4b3aa303f588ba752257694c9c9be3e7ebb11b4aca659b5d", size = 1935226, upload-time = "2026-05-06T13:40:40.428Z" }, + { url = "https://files.pythonhosted.org/packages/e8/e7/1955d28d1afc56dd4b3ad7cc0cf39df1b9852964cf16e5d13912756d6d6b/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29c61fc04a3d840155ff08e475a04809278972fe6aef51e2720554e96367e34b", size = 1974605, upload-time = "2026-05-06T13:37:32.029Z" }, + { url = "https://files.pythonhosted.org/packages/93/e2/3fedbf0ba7a22850e6e9fd78117f1c0f10f950182344d8a6c535d468fdd8/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c50f2528cf200c5eed56faf3f4e22fcd5f38c157a8b78576e6ba3168ec35f000", size = 2030777, upload-time = "2026-05-06T13:38:55.239Z" }, + { url = "https://files.pythonhosted.org/packages/f8/61/46be275fcaaba0b4f5b9669dd852267ce1ff616592dccf7a7845588df091/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0cbe8b01f948de4286c74cdd6c667aceb38f5c1e26f0693b3983d9d74887c65e", size = 2236641, upload-time = "2026-05-06T13:37:08.096Z" }, + { url = "https://files.pythonhosted.org/packages/60/db/12e93e46a8bac9988be3c016860f83293daea8c716c029c9ace279036f2f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:617d7e2ca7dcb8c5cf6bcb8c59b8832c94b36196bbf1cbd1bfb56ed341905edd", size = 2286404, upload-time = "2026-05-06T13:40:20.221Z" }, + { url = "https://files.pythonhosted.org/packages/e2/4a/4d8b19008f38d31c53b8219cfedc2e3d5de5fe99d90076b7e767de29274f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7027560ee92211647d0d34e3f7cd6f50da56399d26a9c8ad0da286d3869a53f3", size = 2109219, upload-time = "2026-05-06T13:38:12.153Z" }, + { url = "https://files.pythonhosted.org/packages/88/70/3cbc40978fefb7bb09c6708d40d4ad1a5d70fd7213c3d17f971de868ec1f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:f99626688942fb746e545232e7726926f3be91b5975f8b55327665fafda991c7", size = 2110594, upload-time = "2026-05-06T13:40:02.971Z" }, + { url = "https://files.pythonhosted.org/packages/9d/20/b8d36736216e29491125531685b2f9e61aa5b4b2599893f8268551da3338/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fc3e9034a63de20e15e8ade85358bc6efc614008cab72898b4b4952bea0509ff", size = 2159542, upload-time = "2026-05-06T13:39:27.506Z" }, + { url = "https://files.pythonhosted.org/packages/1d/a2/367df868eb584dacf6bf82a389272406d7178e301c4ac82545ab98bc2dd9/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:97e7cf2be5c77b7d1a9713a05605d49460d02c6078d38d8bef3cbe323c548424", size = 2168146, upload-time = "2026-05-06T13:38:31.93Z" }, + { url = "https://files.pythonhosted.org/packages/c1/b8/4460f77f7e201893f649a29ab355dddd3beee8a97bcb1a320db414f9a06e/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:3bf92c5d0e00fefaab325a4d27828fe6b6e2a21848686b5b60d2d9eeb09d76c6", size = 2306309, upload-time = "2026-05-06T13:37:44.717Z" }, + { url = "https://files.pythonhosted.org/packages/64/c4/be2639293acd87dc8ddbcec41a73cee9b2ebf996fe6d892a1a74e88ad3f7/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:3ecbc122d18468d06ca279dc26a8c2e2d5acb10943bb35e36ae92096dc3b5565", size = 2369736, upload-time = "2026-05-06T13:37:05.645Z" }, + { url = "https://files.pythonhosted.org/packages/30/a6/9f9f380dbb301f67023bf8f707aaa75daadf84f7152d95c410fd7e81d994/pydantic_core-2.46.4-cp314-cp314t-win32.whl", hash = "sha256:e846ae7835bf0703ae43f534ab79a867146dadd59dc9ca5c8b53d5c8f7c9ef02", size = 1955575, upload-time = "2026-05-06T13:38:51.116Z" }, + { url = "https://files.pythonhosted.org/packages/40/1f/f1eb9eb350e795d1af8586289746f5c5677d16043040d63710e22abc43c9/pydantic_core-2.46.4-cp314-cp314t-win_amd64.whl", hash = "sha256:2108ba5c1c1eca18030634489dc544844144ee36357f2f9f780b93e7ddbb44b5", size = 2051624, upload-time = "2026-05-06T13:38:21.672Z" }, + { url = "https://files.pythonhosted.org/packages/f6/d2/42dd53d0a85c27606f316d3aa5d2869c4e8470a5ed6dec30e4a1abe19192/pydantic_core-2.46.4-cp314-cp314t-win_arm64.whl", hash = "sha256:4fcbe087dbc2068af7eda3aa87634eba216dbda64d1ae73c8684b621d33f6596", size = 2017325, upload-time = "2026-05-06T13:40:52.723Z" }, { url = "https://files.pythonhosted.org/packages/9d/1d/8987ad40f65ae1432753072f214fb5c74fe47ffbd0698bb9cbbb585664f8/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:1d8ba486450b14f3b1d63bc521d410ec7565e52f887b9fb671791886436a42f7", size = 2095527, upload-time = "2026-05-06T13:39:52.283Z" }, { url = "https://files.pythonhosted.org/packages/64/d3/84c282a7eee1d3ac4c0377546ef5a1ea436ce26840d9ac3b7ed54a377507/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:3009f12e4e90b7f88b4f9adb1b0c4a3d58fe7820f3238c190047209d148026df", size = 1936024, upload-time = "2026-05-06T13:40:15.671Z" }, { url = "https://files.pythonhosted.org/packages/d7/ca/eac61596cdeb4d7e174d3dc0bd8a6238f14f75f97a24e7b7db4c7e7340a0/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad785e92e6dc634c21555edc8bd6b64957ab844541bcb96a1366c202951ae526", size = 1990696, upload-time = "2026-05-06T13:38:34.717Z" }, @@ -4856,46 +4859,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/17/c1/3226e6d7f5a4f736f38ac11a6fbb262d701889802595cdb0f53a885ac2e0/pydantic_extra_types-2.11.1-py3-none-any.whl", hash = "sha256:1722ea2bddae5628ace25f2aa685b69978ef533123e5638cfbddb999e0100ec1", size = 79526, upload-time = "2026-03-16T08:08:02.533Z" }, ] -[[package]] -name = "pydantic-settings" -version = "2.14.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pydantic" }, - { name = "python-dotenv" }, - { name = "typing-inspection" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/5c/b5/8f48e906c3e0205276e8bd8cb7512217a87b2685304d64be27cad5b3019f/pydantic_settings-2.14.2.tar.gz", hash = "sha256:c19dd64b19097f1de80184f0cc7b0272a13ae6e170cbf240a3e27e381ed14a5f", size = 237700, upload-time = "2026-06-19T13:44:56.324Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/77/c1/6e422f34e569cf8e18df68d1939c81c099d2b61e4f7d9621c8a77560799c/pydantic_settings-2.14.2-py3-none-any.whl", hash = "sha256:a20c97b37910b6550d5ea50fbcc2d4187defe58cd57070b73863d069419c9440", size = 61715, upload-time = "2026-06-19T13:44:55.02Z" }, -] - -[[package]] -name = "pydantic-zarr" -version = "0.10.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "numpy" }, - { name = "packaging" }, - { name = "pydantic" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/2f/57/aac9e500abe15719b7406d55871fc8787e7d0ebf83de5f98d44471139f70/pydantic_zarr-0.10.0.tar.gz", hash = "sha256:996b5b4225fb05757e7fff831ee7a75c61f54514a4c2493c7b79635bade7b415", size = 80374, upload-time = "2026-04-23T14:23:12.575Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c7/05/04af0ca9c5747c95591a549509ebbb0a986155015de59f1e4c984e3af9ab/pydantic_zarr-0.10.0-py3-none-any.whl", hash = "sha256:d15769dab43346b070051fdf6e83509d7f55259dd00c6d12be2400935117e230", size = 52809, upload-time = "2026-04-23T14:23:11.011Z" }, -] - -[[package]] -name = "pydot" -version = "4.0.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pyparsing" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/50/35/b17cb89ff865484c6a20ef46bf9d95a5f07328292578de0b295f4a6beec2/pydot-4.0.1.tar.gz", hash = "sha256:c2148f681c4a33e08bf0e26a9e5f8e4099a82e0e2a068098f32ce86577364ad5", size = 162594, upload-time = "2025-06-17T20:09:56.454Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/32/a7125fb28c4261a627f999d5fb4afff25b523800faed2c30979949d6facd/pydot-4.0.1-py3-none-any.whl", hash = "sha256:869c0efadd2708c0be1f916eb669f3d664ca684bc57ffb7ecc08e70d5e93fee6", size = 37087, upload-time = "2025-06-17T20:09:55.25Z" }, -] - [[package]] name = "pygments" version = "2.20.0" @@ -4947,15 +4910,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b2/e6/94145d714402fd5ade00b5661f2d0ab981219e07f7db9bfa16786cdb9c04/pynndescent-0.6.0-py3-none-any.whl", hash = "sha256:dc8c74844e4c7f5cbd1e0cd6909da86fdc789e6ff4997336e344779c3d5538ef", size = 73511, upload-time = "2026-01-08T21:29:57.306Z" }, ] -[[package]] -name = "pyopengl" -version = "3.1.10" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6f/16/912b7225d56284859cd9a672827f18be43f8012f8b7b932bc4bd959a298e/pyopengl-3.1.10.tar.gz", hash = "sha256:c4a02d6866b54eb119c8e9b3fb04fa835a95ab802dd96607ab4cdb0012df8335", size = 1915580, upload-time = "2025-08-18T02:33:01.76Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/de/e4/1ba6f44e491c4eece978685230dde56b14d51a0365bc1b774ddaa94d14cd/pyopengl-3.1.10-py3-none-any.whl", hash = "sha256:794a943daced39300879e4e47bd94525280685f42dbb5a998d336cfff151d74f", size = 3194996, upload-time = "2025-08-18T02:32:59.902Z" }, -] - [[package]] name = "pyparsing" version = "3.3.2" @@ -4965,81 +4919,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" }, ] -[[package]] -name = "pyproject-hooks" -version = "1.2.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e7/82/28175b2414effca1cdac8dc99f76d660e7a4fb0ceefa4b4ab8f5f6742925/pyproject_hooks-1.2.0.tar.gz", hash = "sha256:1e859bd5c40fae9448642dd871adf459e5e2084186e8d2c2a79a824c970da1f8", size = 19228, upload-time = "2024-09-29T09:24:13.293Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/bd/24/12818598c362d7f300f18e74db45963dbcb85150324092410c8b49405e42/pyproject_hooks-1.2.0-py3-none-any.whl", hash = "sha256:9e5c6bfa8dcc30091c74b0cf803c81fdd29d94f01992a7707bc97babb1141913", size = 10216, upload-time = "2024-09-29T09:24:11.978Z" }, -] - -[[package]] -name = "pyqt5" -version = "5.15.11" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pyqt5-qt5", version = "5.15.2", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, - { name = "pyqt5-qt5", version = "5.15.19", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform == 'emscripten' or sys_platform == 'win32'" }, - { name = "pyqt5-sip" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/0e/07/c9ed0bd428df6f87183fca565a79fee19fa7c88c7f00a7f011ab4379e77a/PyQt5-5.15.11.tar.gz", hash = "sha256:fda45743ebb4a27b4b1a51c6d8ef455c4c1b5d610c90d2934c7802b5c1557c52", size = 3216775, upload-time = "2024-07-19T08:39:57.756Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/11/64/42ec1b0bd72d87f87bde6ceb6869f444d91a2d601f2e67cd05febc0346a1/PyQt5-5.15.11-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:c8b03dd9380bb13c804f0bdb0f4956067f281785b5e12303d529f0462f9afdc2", size = 6579776, upload-time = "2024-07-19T08:39:19.775Z" }, - { url = "https://files.pythonhosted.org/packages/49/f5/3fb696f4683ea45d68b7e77302eff173493ac81e43d63adb60fa760b9f91/PyQt5-5.15.11-cp38-abi3-macosx_11_0_x86_64.whl", hash = "sha256:6cd75628f6e732b1ffcfe709ab833a0716c0445d7aec8046a48d5843352becb6", size = 7016415, upload-time = "2024-07-19T08:39:32.977Z" }, - { url = "https://files.pythonhosted.org/packages/b4/8c/4065950f9d013c4b2e588fe33cf04e564c2322842d84dbcbce5ba1dc28b0/PyQt5-5.15.11-cp38-abi3-manylinux_2_17_x86_64.whl", hash = "sha256:cd672a6738d1ae33ef7d9efa8e6cb0a1525ecf53ec86da80a9e1b6ec38c8d0f1", size = 8188103, upload-time = "2024-07-19T08:39:40.561Z" }, - { url = "https://files.pythonhosted.org/packages/f3/f0/ae5a5b4f9b826b29ea4be841b2f2d951bcf5ae1d802f3732b145b57c5355/PyQt5-5.15.11-cp38-abi3-win32.whl", hash = "sha256:76be0322ceda5deecd1708a8d628e698089a1cea80d1a49d242a6d579a40babd", size = 5433308, upload-time = "2024-07-19T08:39:46.932Z" }, - { url = "https://files.pythonhosted.org/packages/56/d5/68eb9f3d19ce65df01b6c7b7a577ad3bbc9ab3a5dd3491a4756e71838ec9/PyQt5-5.15.11-cp38-abi3-win_amd64.whl", hash = "sha256:bdde598a3bb95022131a5c9ea62e0a96bd6fb28932cc1619fd7ba211531b7517", size = 6865864, upload-time = "2024-07-19T08:39:53.572Z" }, -] - -[[package]] -name = "pyqt5-qt5" -version = "5.15.2" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", - "python_full_version < '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", - "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", - "python_full_version < '3.13' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", -] -wheels = [ - { url = "https://files.pythonhosted.org/packages/62/09/99a222b0360616250fb2e6003a54e43a2a06b0774f0f8d5daafb86a2c375/PyQt5_Qt5-5.15.2-py3-none-macosx_10_13_intel.whl", hash = "sha256:76980cd3d7ae87e3c7a33bfebfaee84448fd650bad6840471d6cae199b56e154", size = 40546019, upload-time = "2021-03-10T13:52:47.763Z" }, - { url = "https://files.pythonhosted.org/packages/83/d4/241a6a518d0bcf0a9fcdcbad5edfed18d43e884317eab8d5230a2b27e206/PyQt5_Qt5-5.15.2-py3-none-manylinux2014_x86_64.whl", hash = "sha256:1988f364ec8caf87a6ee5d5a3a5210d57539988bf8e84714c7d60972692e2f4a", size = 59921716, upload-time = "2021-03-10T13:57:39.485Z" }, -] - -[[package]] -name = "pyqt5-qt5" -version = "5.15.19" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'win32'", - "python_full_version < '3.13' and platform_machine != 's390x' and sys_platform == 'win32'", - "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'win32'", - "python_full_version < '3.13' and platform_machine == 's390x' and sys_platform == 'win32'", - "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'emscripten'", - "python_full_version < '3.13' and platform_machine != 's390x' and sys_platform == 'emscripten'", - "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'emscripten'", - "python_full_version < '3.13' and platform_machine == 's390x' and sys_platform == 'emscripten'", -] - -[[package]] -name = "pyqt5-sip" -version = "12.18.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f3/31/5ef342de9faee0f3801088946ae103db9b9eaeba3d6a64fefd5ce74df244/pyqt5_sip-12.18.0.tar.gz", hash = "sha256:71c37db75a0664325de149f43e2a712ec5fa1f90429a21dafbca005cb6767f94", size = 104143, upload-time = "2026-01-13T15:53:19.576Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/2a/61/6d78d702016ac23d2b97634a3b6a831c3f7735f0552a1c8b058db96005d1/pyqt5_sip-12.18.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b29e4cda24748e59e5bd1bdad4812091a86b4b5b08c38b7f781eb55a5166f2b7", size = 124614, upload-time = "2026-01-13T15:52:57.59Z" }, - { url = "https://files.pythonhosted.org/packages/19/bf/8f3efa10ddd3e76c1253865340ab7c2960ef96681d732b1f666c77430612/pyqt5_sip-12.18.0-cp312-cp312-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:163c2bba5e637c2222ec17d82a2c5aa158184a191923eb7d137cf4cfa0399529", size = 339412, upload-time = "2026-01-13T15:53:00.563Z" }, - { url = "https://files.pythonhosted.org/packages/72/48/f1bcf6729d01bae6729cd790b22fd579dbe34014e8be031e6f10c5b9b2aa/pyqt5_sip-12.18.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:ead5e0a64ad852ac60797989d8444a6a5bd834768536b04a07b40b2937d922f6", size = 282376, upload-time = "2026-01-13T15:52:59.172Z" }, - { url = "https://files.pythonhosted.org/packages/dd/b7/d84c764ac9f1366be561255ec9bd88ee224fefdbdb349aee250f3003f0ca/pyqt5_sip-12.18.0-cp312-cp312-win32.whl", hash = "sha256:993fe3ed9a62a92e770f32d5344e3df56c2cacf1471f01b7feaf04818a2df1c4", size = 49523, upload-time = "2026-01-13T15:53:03.068Z" }, - { url = "https://files.pythonhosted.org/packages/ab/e7/ef87178d5afa5f63be38556dc0df8af89f9bf74f2555f4dab6824c0fd150/pyqt5_sip-12.18.0-cp312-cp312-win_amd64.whl", hash = "sha256:9b689e02e400abd1ce0a30cd6eae8eceabcf1bbba0395cb5c86e64ba74351d68", size = 58001, upload-time = "2026-01-13T15:53:02.15Z" }, - { url = "https://files.pythonhosted.org/packages/79/67/8d43d0fea10ff48ddecc8534aead8b855dc80df80653b8b1bf9e1f993063/pyqt5_sip-12.18.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9254e5dd7676b76503ba20edcc919e7ac4a97b6c70a6fb2f9dba9e13b4c60509", size = 124605, upload-time = "2026-01-13T15:53:04.991Z" }, - { url = "https://files.pythonhosted.org/packages/48/2a/b08bc8efeb49c50c6cdac11417dc2c8eaefcac2f0a6382eae7b26dc0f232/pyqt5_sip-12.18.0-cp313-cp313-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c969631ada7293a81e1012b2264a62d69a91995b517586489dfe24421b87b9af", size = 339918, upload-time = "2026-01-13T15:53:08.502Z" }, - { url = "https://files.pythonhosted.org/packages/b6/99/24f82437b2f073cf39296b7c731b6a8bc0f5207911fdd93841a0ea9abe42/pyqt5_sip-12.18.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:d84ac384a63285132e67762c87681191c25e28a1df7560287ec3889d9eb223b5", size = 282088, upload-time = "2026-01-13T15:53:06.632Z" }, - { url = "https://files.pythonhosted.org/packages/3e/27/20d3924943df34361fae9c6a0489ae89d0b07571693245c61678d185e4a4/pyqt5_sip-12.18.0-cp313-cp313-win32.whl", hash = "sha256:95bba4670ecf5cba73958b85aa2087c17838a402ed251c38e68060c7665c998b", size = 49501, upload-time = "2026-01-13T15:53:11.159Z" }, - { url = "https://files.pythonhosted.org/packages/3f/36/e251623c12968730730512a9e5150430e36246afbe64894610190b896f61/pyqt5_sip-12.18.0-cp313-cp313-win_amd64.whl", hash = "sha256:aac4adc37df2f2ac1dc259409be1900f07332d140a12c9db7c84112cef64ff59", size = 58076, upload-time = "2026-01-13T15:53:09.928Z" }, -] - [[package]] name = "pyqtgraph" version = "0.14.0" @@ -5071,6 +4950,16 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fa/6f/5173067773b5e650566f90c3356bd3a71c02349e6644222a8971c0196687/pyscipopt-6.2.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8860afb9d43c93b653c7295ef674ad1ba156c731591fb7e33b5991c1136b0dc6", size = 16207762, upload-time = "2026-05-16T15:05:26.883Z" }, { url = "https://files.pythonhosted.org/packages/57/76/59288c92b7ee914c351c6003b63249e0702d990d1fdd9ff97e65ffc1c57b/pyscipopt-6.2.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:725503ea90fd0962f1111a5b46ee3e271b7375e1b0dfda708ce223dbebaeff5e", size = 17560629, upload-time = "2026-05-16T15:05:30.298Z" }, { url = "https://files.pythonhosted.org/packages/0d/42/2b1d48d11311c2fda215c8da83f8f8cabec3b5a82936a7229919ad9141e5/pyscipopt-6.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a5621ddcb59f7816e87c3deeb1bf52f8693e016a1a29148201b712adb84956e3", size = 48215647, upload-time = "2026-05-16T15:05:36.5Z" }, + { url = "https://files.pythonhosted.org/packages/fc/af/4ddfd3802ff69ad58f44e6d96878265c4ea55cac2313aae1994611b0d6aa/pyscipopt-6.2.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:299dbff65d60853d545788457d02720e3693df19ade4aaba1bbe8b575239ff4b", size = 8418209, upload-time = "2026-05-16T15:05:40.166Z" }, + { url = "https://files.pythonhosted.org/packages/9a/53/61ab5575a6e29547b6d13c37d7005b3f348897b48dd6cbcd4261196f2e25/pyscipopt-6.2.1-cp314-cp314-macosx_11_0_x86_64.whl", hash = "sha256:8bd6fb0f2a6c8bf4ef49e524d4c022b7b539098193ce312e94d29c6254658ff6", size = 12267358, upload-time = "2026-05-16T15:05:43.17Z" }, + { url = "https://files.pythonhosted.org/packages/c9/fd/851dedcabdb6d6168eae0e2c31008d02f20cf018b05d091a5bda6f5da6a1/pyscipopt-6.2.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bb7858ceececa09658c3bfa58476862255353fea52d4f512ff97160f138f92cd", size = 16171696, upload-time = "2026-05-16T15:05:46.851Z" }, + { url = "https://files.pythonhosted.org/packages/86/7e/ac663246709e6ab94b225c40e9dac863a91b1b86e12c2ea65c951f944bea/pyscipopt-6.2.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9cdf0e460b834f06ea68a13e59f581f7ecbec5a466a76bbf1267ac5b4573bb52", size = 17430536, upload-time = "2026-05-16T15:05:50.267Z" }, + { url = "https://files.pythonhosted.org/packages/6f/ca/05d80040767d1d2443ea6cd6cc42985cdd532feeaecfcc19f103c8b45a1b/pyscipopt-6.2.1-cp314-cp314-win_amd64.whl", hash = "sha256:6aed03b621decb09b38f399773bf8cf2c707e965990b778a24d28c8cc90a0756", size = 49375214, upload-time = "2026-05-16T15:05:56.493Z" }, + { url = "https://files.pythonhosted.org/packages/05/d4/caa18165a2faf876d8d482b0b92bd75abf284af2b51b64ebee62c1b47065/pyscipopt-6.2.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:18c6283b8fc47929787a043204e7bb26f41e414d1e8597d394057bcc60fc3ee0", size = 8528074, upload-time = "2026-05-16T15:05:59.776Z" }, + { url = "https://files.pythonhosted.org/packages/0f/3c/f6593bf4459e788f2302878369c5eb65ec5b04fd6e18524296fe05365c6b/pyscipopt-6.2.1-cp314-cp314t-macosx_11_0_x86_64.whl", hash = "sha256:622e9640cdfc22632079ed4f73d88653d6170ee89ca6bdb6459d0db334fa7a87", size = 12341833, upload-time = "2026-05-16T15:06:02.402Z" }, + { url = "https://files.pythonhosted.org/packages/49/db/bc80dfa03ef13701b818aca26428fe05c389a71a8ec5654e1e4ea60ef3a4/pyscipopt-6.2.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a85fb7f73fd06fad9a0358b2eb47d94dbe94ee52baf85e045beb5e216022b6c7", size = 16735540, upload-time = "2026-05-16T15:06:05.522Z" }, + { url = "https://files.pythonhosted.org/packages/58/ee/97cd080513efdedea2fcd1f9b71d02e775f5e445ab39f8f012c14e4b4c5e/pyscipopt-6.2.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d323fa83b855308587794cd0ab04ae6dd341c227202d0ddaec2761917034e972", size = 17628571, upload-time = "2026-05-16T15:06:09.608Z" }, + { url = "https://files.pythonhosted.org/packages/7b/75/e280c162ae55a5db7f9031c4b92774964a8eebef94d2d463a389c9f6294b/pyscipopt-6.2.1-cp314-cp314t-win_amd64.whl", hash = "sha256:138e312cd692b7c853e7eab572986bc6d2dd28acd6e16347d73c96c225613056", size = 49551043, upload-time = "2026-05-16T15:06:15.368Z" }, ] [[package]] @@ -5104,24 +4993,28 @@ wheels = [ ] [[package]] -name = "python-dateutil" -version = "2.9.0.post0" +name = "pytest-xdist" +version = "3.8.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "six" }, + { name = "execnet" }, + { name = "pytest" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } +sdist = { url = "https://files.pythonhosted.org/packages/78/b4/439b179d1ff526791eb921115fca8e44e596a13efeda518b9d845a619450/pytest_xdist-3.8.0.tar.gz", hash = "sha256:7e578125ec9bc6050861aa93f2d59f1d8d085595d6551c2c90b6f4fad8d3a9f1", size = 88069, upload-time = "2025-07-01T13:30:59.346Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, + { url = "https://files.pythonhosted.org/packages/ca/31/d4e37e9e550c2b92a9cbc2e4d0b7420a27224968580b5a447f420847c975/pytest_xdist-3.8.0-py3-none-any.whl", hash = "sha256:202ca578cfeb7370784a8c33d6d05bc6e13b4f25b5053c30a152269fd10f0b88", size = 46396, upload-time = "2025-07-01T13:30:56.632Z" }, ] [[package]] -name = "python-dotenv" -version = "1.2.2" +name = "python-dateutil" +version = "2.9.0.post0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" }, + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, ] [[package]] @@ -5209,19 +5102,22 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/91/fe/2b70276ede7878c5fe8356ca07574db5da63e222ce39a463e84bfad135e8/pywavelets-1.9.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:3830e6657236b53a3aae20c735cccead942bb97c54bbca9e7d07bae01645fe9c", size = 4477528, upload-time = "2025-08-04T16:19:35.932Z" }, { url = "https://files.pythonhosted.org/packages/e7/ed/d58b540c15e36508cfeded7b0d39493e811b0dce18d9d4e6787fb2e89685/pywavelets-1.9.0-cp313-cp313t-win32.whl", hash = "sha256:81bb65facfbd7b50dec50450516e72cdc51376ecfdd46f2e945bb89d39bfb783", size = 4186493, upload-time = "2025-08-04T16:19:37.198Z" }, { url = "https://files.pythonhosted.org/packages/84/b2/12a849650d618a86bbe4d8876c7e20a7afe59a8cad6f49c57eca9af26dfa/pywavelets-1.9.0-cp313-cp313t-win_amd64.whl", hash = "sha256:47d52cf35e2afded8cfe1133663f6f67106a3220b77645476ae660ad34922cb4", size = 4274821, upload-time = "2025-08-04T16:19:38.436Z" }, -] - -[[package]] -name = "pywin32" -version = "312" -source = { registry = "https://pypi.org/simple" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/83/ff/32aa7d2ed0ab12b323aaa64f9b75e6ad4f8fd09f9ccfc28c79414d46838d/pywin32-312-cp312-cp312-win32.whl", hash = "sha256:dab4f65ac9c4e48400a2a0530c46c3c579cd5905ecd11b80692373915269208b", size = 6371877, upload-time = "2026-06-04T07:49:28.836Z" }, - { url = "https://files.pythonhosted.org/packages/03/d9/77040d3b43df3f3be32ea289433d660d2727f5ba327bc73be835127d9d60/pywin32-312-cp312-cp312-win_amd64.whl", hash = "sha256:b457f6d628a47e8a7346ce22acb7e1a46a4a78b52e1d17e1af56871bd19a93bc", size = 6914841, upload-time = "2026-06-04T07:49:31.85Z" }, - { url = "https://files.pythonhosted.org/packages/e3/cc/7b1ec671775756020a0ee7f4feeaf3c568f0ab86bd3900088cf986937a92/pywin32-312-cp312-cp312-win_arm64.whl", hash = "sha256:6017c58e12f6809fbb0555b75df144c2922a9ffd18e4b9b5afa863b6c1a9d950", size = 6727901, upload-time = "2026-06-04T07:49:34.244Z" }, - { url = "https://files.pythonhosted.org/packages/2d/41/12fbfd7f36ed2146d8bc9de96c2741296bf0d490b98508496cff322e274c/pywin32-312-cp313-cp313-win32.whl", hash = "sha256:7a27df850933d16a8eabfbaeb73d52b273e2da667f80d70b01a89d1f6828d02c", size = 6370184, upload-time = "2026-06-04T07:49:36.253Z" }, - { url = "https://files.pythonhosted.org/packages/ba/db/36a78e3403099d31d9746d13fdcde5accc43c1155f375a34d15983a479a7/pywin32-312-cp313-cp313-win_amd64.whl", hash = "sha256:c53e878d15a1c44788082bfe712a905433473aa38f86375b7cf8b45e3acbaaf9", size = 6914298, upload-time = "2026-06-04T07:49:38.876Z" }, - { url = "https://files.pythonhosted.org/packages/84/37/c1697194092b76de9ed47ca124323f02c57ffc8a45c06f88a3d5acaf01eb/pywin32-312-cp313-cp313-win_arm64.whl", hash = "sha256:59aba5d5940842075343a5ddc6b11f1cdf0d1567fe745290359dfbcc7c2eb831", size = 6727640, upload-time = "2026-06-04T07:49:41.083Z" }, + { url = "https://files.pythonhosted.org/packages/ba/1f/18c82122547c9eec2232d800b02ada1fbd30ce2136137b5738acca9d653e/pywavelets-1.9.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:53043d2f3f4e55a576f51ac594fe33181e1d096d958e01524db5070eb3825306", size = 4314440, upload-time = "2025-08-04T16:19:39.701Z" }, + { url = "https://files.pythonhosted.org/packages/eb/e1/1c92ac6b538ef5388caf1a74af61cf6af16ea6d14115bb53357469cb38d6/pywavelets-1.9.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:56bc36b42b1b125fd9cb56e7956b22f8d0f83c1093f49c77fc042135e588c799", size = 4290162, upload-time = "2025-08-04T16:19:41.322Z" }, + { url = "https://files.pythonhosted.org/packages/96/d3/d856a2cac8069c20144598fa30a43ca40b5df2e633230848a9a942faf04a/pywavelets-1.9.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:08076eb9a182ddc6054ac86868fb71df6267c341635036dc63d20bdbacd9ad7e", size = 4437162, upload-time = "2025-08-04T16:19:42.556Z" }, + { url = "https://files.pythonhosted.org/packages/c9/54/777e0495acd4fb008791e84889be33d6e7fc8af095b441d939390b7d2491/pywavelets-1.9.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4ee1ee7d80f88c64b8ec3b5021dd1e94545cc97f0cd479fb51aa7b10f6def08e", size = 4498169, upload-time = "2025-08-04T16:19:43.791Z" }, + { url = "https://files.pythonhosted.org/packages/76/68/81b97f4d18491a18fbe17e06e2eee80a591ce445942f7b6f522de07813c5/pywavelets-1.9.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:3226b6f62838a6ccd7782cb7449ee5d8b9d61999506c1d9b03b2baf41b01b6fd", size = 4443318, upload-time = "2025-08-04T16:19:45.368Z" }, + { url = "https://files.pythonhosted.org/packages/92/74/5147f2f0436f7aa131cb1bc13dba32ef5f3862748ae1c7366b4cde380362/pywavelets-1.9.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9fb7f4b11d18e2db6dd8deee7b3ce8343d45f195f3f278c2af6e3724b1b93a24", size = 4503294, upload-time = "2025-08-04T16:19:46.632Z" }, + { url = "https://files.pythonhosted.org/packages/3d/d4/af998cc71e869919e0ab45471bd43e91d055ac7bc3ce6f56cc792c9b6bc8/pywavelets-1.9.0-cp314-cp314-win32.whl", hash = "sha256:9902d9fc9812588ab2dce359a1307d8e7f002b53a835640e2c9388fe62a82fd4", size = 4144478, upload-time = "2025-08-04T16:19:47.974Z" }, + { url = "https://files.pythonhosted.org/packages/7d/66/1d071eae5cc3e3ad0e45334462f8ce526a79767ccb759eb851aa5b78a73a/pywavelets-1.9.0-cp314-cp314-win_amd64.whl", hash = "sha256:7e57792bde40e331d6cc65458e5970fd814dba18cfc4e9add9d051e901a7b7c7", size = 4227186, upload-time = "2025-08-04T16:19:49.57Z" }, + { url = "https://files.pythonhosted.org/packages/bf/1f/da0c03ac99bd9d20409c0acf6417806d4cf333d70621da9f535dd0cf27fa/pywavelets-1.9.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b47c72fb4b76d665c4c598a5b621b505944e5b761bf03df9d169029aafcb652f", size = 4354391, upload-time = "2025-08-04T16:19:51.221Z" }, + { url = "https://files.pythonhosted.org/packages/95/b6/de9e225d8cc307fbb4fda88aefa79442775d5e27c58ee4d3c8a8580ceba6/pywavelets-1.9.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:969e369899e7eab546ea5d77074e4125082e6f9dad71966499bf5dee3758be55", size = 4335810, upload-time = "2025-08-04T16:19:52.813Z" }, + { url = "https://files.pythonhosted.org/packages/33/3b/336761359d07cd44a4233ca854704ff2a9e78d285879ccc82d254b9daa57/pywavelets-1.9.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8aeffd4f35036c1fade972a61454de5709a7a8fc9a7d177eefe3ac34d76962e5", size = 4422220, upload-time = "2025-08-04T16:19:54.068Z" }, + { url = "https://files.pythonhosted.org/packages/98/61/76ccc7ada127f14f65eda40e37407b344fd3713acfca7a94d7f0f67fe57d/pywavelets-1.9.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f63f400fcd4e7007529bd06a5886009760da35cd7e76bb6adb5a5fbee4ffeb8c", size = 4470156, upload-time = "2025-08-04T16:19:55.379Z" }, + { url = "https://files.pythonhosted.org/packages/e0/de/142ca27ee729cf64113c2560748fcf2bd45b899ff282d6f6f3c0e7f177bb/pywavelets-1.9.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:a63bcb6b5759a7eb187aeb5e8cd316b7adab7de1f4b5a0446c9a6bcebdfc22fb", size = 4430167, upload-time = "2025-08-04T16:19:56.566Z" }, + { url = "https://files.pythonhosted.org/packages/ca/5e/90b39adff710d698c00ba9c3125e2bec99dad7c5f1a3ba37c73a78a6689f/pywavelets-1.9.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9950eb7c8b942e9bfa53d87c7e45a420dcddbd835c4c5f1aca045a3f775c6113", size = 4477378, upload-time = "2025-08-04T16:19:58.162Z" }, + { url = "https://files.pythonhosted.org/packages/f1/1a/89f5f4ebcb9d34d9b7b2ac0a868c8b6d8c78d699a36f54407a060cea0566/pywavelets-1.9.0-cp314-cp314t-win32.whl", hash = "sha256:097f157e07858a1eb370e0d9c1bd11185acdece5cca10756d6c3c7b35b52771a", size = 4209132, upload-time = "2025-08-04T16:20:00.371Z" }, + { url = "https://files.pythonhosted.org/packages/68/d2/a8065103f5e2e613b916489e6c85af6402a1ec64f346d1429e2d32cb8d03/pywavelets-1.9.0-cp314-cp314t-win_amd64.whl", hash = "sha256:3b6ff6ba4f625d8c955f68c2c39b0a913776d406ab31ee4057f34ad4019fb33b", size = 4306793, upload-time = "2025-08-04T16:20:02.934Z" }, ] [[package]] @@ -5236,6 +5132,10 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fd/50/724ed5c38c504d4e58a88a072776a1e880d970789deaeb2b9f7bd9a5141a/pywinpty-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:fe1f7911805127c94cf51f89ab14096c6f91ffdcacf993d2da6082b2142a2523", size = 234591, upload-time = "2026-02-04T21:52:29.821Z" }, { url = "https://files.pythonhosted.org/packages/f7/ad/90a110538696b12b39fd8758a06d70ded899308198ad2305ac68e361126e/pywinpty-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:3f07a6cf1c1d470d284e614733c3d0f726d2c85e78508ea10a403140c3c0c18a", size = 2112360, upload-time = "2026-02-04T21:55:33.397Z" }, { url = "https://files.pythonhosted.org/packages/44/0f/7ffa221757a220402bc79fda44044c3f2cc57338d878ab7d622add6f4581/pywinpty-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:15c7c0b6f8e9d87aabbaff76468dabf6e6121332c40fc1d83548d02a9d6a3759", size = 233107, upload-time = "2026-02-04T21:51:45.455Z" }, + { url = "https://files.pythonhosted.org/packages/28/88/2ff917caff61e55f38bcdb27de06ee30597881b2cae44fbba7627be015c4/pywinpty-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:d4b6b7b0fe0cdcd02e956bd57cfe9f4e5a06514eecf3b5ae174da4f951b58be9", size = 2113282, upload-time = "2026-02-04T21:52:08.188Z" }, + { url = "https://files.pythonhosted.org/packages/63/32/40a775343ace542cc43ece3f1d1fce454021521ecac41c4c4573081c2336/pywinpty-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:34789d685fc0d547ce0c8a65e5a70e56f77d732fa6e03c8f74fefb8cbb252019", size = 234207, upload-time = "2026-02-04T21:51:58.687Z" }, + { url = "https://files.pythonhosted.org/packages/8d/54/5d5e52f4cb75028104ca6faf36c10f9692389b1986d34471663b4ebebd6d/pywinpty-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:0c37e224a47a971d1a6e08649a1714dac4f63c11920780977829ed5c8cadead1", size = 2112910, upload-time = "2026-02-04T21:52:30.976Z" }, + { url = "https://files.pythonhosted.org/packages/0a/44/dcd184824e21d4620b06c7db9fbb15c3ad0a0f1fa2e6de79969fb82647ec/pywinpty-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:c4e9c3dff7d86ba81937438d5819f19f385a39d8f592d4e8af67148ceb4f6ab5", size = 233425, upload-time = "2026-02-04T21:51:56.754Z" }, ] [[package]] @@ -5264,6 +5164,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, ] [[package]] @@ -5309,37 +5227,16 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/4f/6f/55c10e2e49ad52d080dc24e37adb215e5b0d64990b57598abc2e3f01725b/pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c", size = 574964, upload-time = "2025-09-08T23:08:37.178Z" }, { url = "https://files.pythonhosted.org/packages/87/4d/2534970ba63dd7c522d8ca80fb92777f362c0f321900667c615e2067cb29/pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2", size = 641029, upload-time = "2025-09-08T23:08:40.595Z" }, { url = "https://files.pythonhosted.org/packages/f6/fa/f8aea7a28b0641f31d40dea42d7ef003fded31e184ef47db696bc74cd610/pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e", size = 561541, upload-time = "2025-09-08T23:08:42.668Z" }, -] - -[[package]] -name = "qtawesome" -version = "1.4.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "qtpy" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/cf/bc/475c8df94de4f358bbf7703747c13b16ae3c0c4cda50d5243b99cb45e2a8/qtawesome-1.4.2.tar.gz", hash = "sha256:b2bf9351beb335095006892796f072ffd9755a2d7e5113dc71918dcd9ba4ef4a", size = 2614207, upload-time = "2026-04-10T18:49:46.037Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/25/b1/da1d826ccc9258674b26dd0abcbbb1c55cab06e7fbf2697518b67edc79fc/qtawesome-1.4.2-py3-none-any.whl", hash = "sha256:dbf08524428fa2df73918ce362153254cd44f089380576d84bfaad8f40eece45", size = 2593557, upload-time = "2026-04-10T18:49:44.219Z" }, -] - -[[package]] -name = "qtconsole" -version = "5.7.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "ipykernel" }, - { name = "ipython-pygments-lexers" }, - { name = "jupyter-client" }, - { name = "jupyter-core" }, - { name = "packaging" }, - { name = "pygments" }, - { name = "qtpy" }, - { name = "traitlets" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/cd/28/4070eb0bacb99bc00bf60173fda25fb6a559d6600040035ba96c196d3647/qtconsole-5.7.2.tar.gz", hash = "sha256:27b485b9161925924c1d8e78e66bb342e6e3bc49bf675d0a67b49bad9c291521", size = 436661, upload-time = "2026-03-25T02:24:38.895Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7a/60/aba9f3c3f1f48c7fbdf03bed45b576a916cd09c08242939b5294b85e37b4/qtconsole-5.7.2-py3-none-any.whl", hash = "sha256:e1d1f6a792123363626e643a7a4ee561217773571043992693fba7eccfa89f95", size = 125883, upload-time = "2026-03-25T02:24:36.95Z" }, + { url = "https://files.pythonhosted.org/packages/87/45/19efbb3000956e82d0331bafca5d9ac19ea2857722fa2caacefb6042f39d/pyzmq-27.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ce980af330231615756acd5154f29813d553ea555485ae712c491cd483df6b7a", size = 1341197, upload-time = "2025-09-08T23:08:44.973Z" }, + { url = "https://files.pythonhosted.org/packages/48/43/d72ccdbf0d73d1343936296665826350cb1e825f92f2db9db3e61c2162a2/pyzmq-27.1.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1779be8c549e54a1c38f805e56d2a2e5c009d26de10921d7d51cfd1c8d4632ea", size = 897175, upload-time = "2025-09-08T23:08:46.601Z" }, + { url = "https://files.pythonhosted.org/packages/2f/2e/a483f73a10b65a9ef0161e817321d39a770b2acf8bcf3004a28d90d14a94/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7200bb0f03345515df50d99d3db206a0a6bee1955fbb8c453c76f5bf0e08fb96", size = 660427, upload-time = "2025-09-08T23:08:48.187Z" }, + { url = "https://files.pythonhosted.org/packages/f5/d2/5f36552c2d3e5685abe60dfa56f91169f7a2d99bbaf67c5271022ab40863/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01c0e07d558b06a60773744ea6251f769cd79a41a97d11b8bf4ab8f034b0424d", size = 847929, upload-time = "2025-09-08T23:08:49.76Z" }, + { url = "https://files.pythonhosted.org/packages/c4/2a/404b331f2b7bf3198e9945f75c4c521f0c6a3a23b51f7a4a401b94a13833/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:80d834abee71f65253c91540445d37c4c561e293ba6e741b992f20a105d69146", size = 1650193, upload-time = "2025-09-08T23:08:51.7Z" }, + { url = "https://files.pythonhosted.org/packages/1c/0b/f4107e33f62a5acf60e3ded67ed33d79b4ce18de432625ce2fc5093d6388/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:544b4e3b7198dde4a62b8ff6685e9802a9a1ebf47e77478a5eb88eca2a82f2fd", size = 2024388, upload-time = "2025-09-08T23:08:53.393Z" }, + { url = "https://files.pythonhosted.org/packages/0d/01/add31fe76512642fd6e40e3a3bd21f4b47e242c8ba33efb6809e37076d9b/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cedc4c68178e59a4046f97eca31b148ddcf51e88677de1ef4e78cf06c5376c9a", size = 1885316, upload-time = "2025-09-08T23:08:55.702Z" }, + { url = "https://files.pythonhosted.org/packages/c4/59/a5f38970f9bf07cee96128de79590bb354917914a9be11272cfc7ff26af0/pyzmq-27.1.0-cp314-cp314t-win32.whl", hash = "sha256:1f0b2a577fd770aa6f053211a55d1c47901f4d537389a034c690291485e5fe92", size = 587472, upload-time = "2025-09-08T23:08:58.18Z" }, + { url = "https://files.pythonhosted.org/packages/70/d8/78b1bad170f93fcf5e3536e70e8fadac55030002275c9a29e8f5719185de/pyzmq-27.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19c9468ae0437f8074af379e986c5d3d7d7bfe033506af442e8c879732bedbe0", size = 661401, upload-time = "2025-09-08T23:08:59.802Z" }, + { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170, upload-time = "2025-09-08T23:09:01.418Z" }, ] [[package]] @@ -5376,15 +5273,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a7/25/4511e114e3f8420a0edd9febd12de1a4a56b3259a779d7ce5d92c5dfd6ac/quilt3-7.3.0-py3-none-any.whl", hash = "sha256:585245b73ad40586af6fc5be689e1113d3e44bcb75e198b3ee9a03a036b79d07", size = 136740, upload-time = "2026-04-07T21:15:31.782Z" }, ] -[[package]] -name = "rangehttpserver" -version = "1.4.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/36/3b/1ec139d6028c6e5eb10301f040d6eee5c5427a4b1b4d614a2f78d3bba1bd/rangehttpserver-1.4.0.tar.gz", hash = "sha256:d5ddccee219b359598e41da0c5fbf30a2579297094f5a682755e2586388a5306", size = 6993, upload-time = "2024-08-27T18:08:43.418Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/2f/43/d7e2b9ad768c07b5473bea3ac7db9ca4d995c09399cbea3d4df1c0bd4955/rangehttpserver-1.4.0-py2.py3-none-any.whl", hash = "sha256:2a0c6926e4341de4cc19ec861292b005e4194ff497b1eefdeccb2992a5045452", size = 7773, upload-time = "2024-08-27T18:08:41.861Z" }, -] - [[package]] name = "referencing" version = "0.37.0" @@ -5453,6 +5341,38 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/04/99/eff29f1037dcab36702c9ee5d6858cf1ce2336ea8ea2987f64245b99ea5e/regex-2026.5.9-cp313-cp313t-win32.whl", hash = "sha256:ed2c9e8068b614c574d8d30e543d617cf5379b0535d46f97ef00e904745a08b5", size = 269951, upload-time = "2026-05-09T23:14:03.661Z" }, { url = "https://files.pythonhosted.org/packages/0e/9d/8870b8981d27b22cda77bb26a5ac7ebfa9c7d9e0dea195a834a82380e748/regex-2026.5.9-cp313-cp313t-win_amd64.whl", hash = "sha256:b46b0f094dc1d3b90356c85a0bd2c9bafc4a6a190b9d6f8ddd5a033b6e088ed4", size = 281240, upload-time = "2026-05-09T23:14:05.56Z" }, { url = "https://files.pythonhosted.org/packages/72/b1/3379415e8f135c13ac551353397cc4fe97b4978f3cac73c5fcbcded548b8/regex-2026.5.9-cp313-cp313t-win_arm64.whl", hash = "sha256:872acc074bd29ffc9913ecdfedf6ea77502312ca44a4aa0d3779089c6069d8de", size = 272383, upload-time = "2026-05-09T23:14:07.843Z" }, + { url = "https://files.pythonhosted.org/packages/13/3e/9c3cd292d8808b3645a2ce517e200179b6d0e903f176300bd8b542e14de5/regex-2026.5.9-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:1bd7587a2948b4085195d5a3374eaf4a425dc3e55784c038175355ecf3bbbf8a", size = 490376, upload-time = "2026-05-09T23:14:09.64Z" }, + { url = "https://files.pythonhosted.org/packages/60/70/d43ee8a2ca0a8b68d167f21658b85520ac0574617c7f320367c5047f7556/regex-2026.5.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:dea2e88e1cce4522496cce630e11e67b98b7076620bc4336c3f674bc21a375f4", size = 291964, upload-time = "2026-05-09T23:14:11.424Z" }, + { url = "https://files.pythonhosted.org/packages/21/91/9d50b433828d8e74196904e168a43abf1e6e88b2a15d47ed742456720c37/regex-2026.5.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2099f7e7ff7b6aa3192312650a56e91cc091e49d50b04e4f6f8b6e28b3b27f1c", size = 289682, upload-time = "2026-05-09T23:14:13.123Z" }, + { url = "https://files.pythonhosted.org/packages/3e/d2/b835e3cafbb9d977736912436259ff551d60919f7d7b3d37d46659c63564/regex-2026.5.9-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecd353045824e4477562a2ac718c25799cdaaa41f7aa925a806a8a3e6848a5b9", size = 796996, upload-time = "2026-05-09T23:14:14.923Z" }, + { url = "https://files.pythonhosted.org/packages/2c/a6/9f992d00019166b9de01c546dd4549bc679f2a68df11b877740b0760b7c2/regex-2026.5.9-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:65c8c8c37377794bd5b2f3ebe51919042bf17aec802e23c833d89782ed0c78af", size = 866089, upload-time = "2026-05-09T23:14:17.757Z" }, + { url = "https://files.pythonhosted.org/packages/e0/08/4d32af657e049b19cb62b02e46e38fe1518797bfb2203ee93a510b21b0dc/regex-2026.5.9-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5b73ab8afcf66c622db143d1c6fda4e58e4d537ee4f125229ad47b1ab80f34c0", size = 911530, upload-time = "2026-05-09T23:14:20.353Z" }, + { url = "https://files.pythonhosted.org/packages/d9/27/2af43dd1dc201d1fecefda64a45f4ad0995855b92724f795a777b402ee69/regex-2026.5.9-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0de5cf193997384ed2ca6f1cd4f78055b255d93d82d5a8cd6ba0d11c10b167e4", size = 800643, upload-time = "2026-05-09T23:14:22.265Z" }, + { url = "https://files.pythonhosted.org/packages/a4/dd/23a249047013b5321d4a60c4d2437462086f601b061776a525e5fba2a59f/regex-2026.5.9-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d641a8c9a61618047796d572a39a79b26167b0411d2c3031937b2fe2d081e2cf", size = 777223, upload-time = "2026-05-09T23:14:24.179Z" }, + { url = "https://files.pythonhosted.org/packages/94/6a/e85ed9538cd19586d0465076a4578a12e093ce776d15f3f8ce92733a8dd6/regex-2026.5.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:24b2355ef5cc9aa5b8f07d17704face1c166fdcc2290fa7bd6e6c925655a8346", size = 785760, upload-time = "2026-05-09T23:14:26.065Z" }, + { url = "https://files.pythonhosted.org/packages/2a/c4/f25473209438638e947c55f9156fd8f236f74169229028cc99116380868e/regex-2026.5.9-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:a24852d3c29ad9e47593593d8a247c44ccc3d0548ef12c822d6ed0810affe676", size = 860891, upload-time = "2026-05-09T23:14:28.17Z" }, + { url = "https://files.pythonhosted.org/packages/f9/f7/f4f86e3c74419c37370e91f150ae0c2ef7d34b2e0e4cdd5da046a02e4022/regex-2026.5.9-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:916714069da19329ef7de197dcbc77bb3104145c7c2c864dbfbe318f46b88b14", size = 765891, upload-time = "2026-05-09T23:14:30.06Z" }, + { url = "https://files.pythonhosted.org/packages/26/70/704d8e13765939146b1cd0ef4e2feb71d7929727d2290f026eed10095955/regex-2026.5.9-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:fa411799ca8da32a8d38d020a88faa5b6f91657d284761352940ecf9f7c3bbdd", size = 851380, upload-time = "2026-05-09T23:14:32.123Z" }, + { url = "https://files.pythonhosted.org/packages/26/29/1a13582a8460038edc38e49f64ceb0dd7c60f5caba77571f4bf6601965d9/regex-2026.5.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1e6da47d679b7010ef27556b6e0f99771b744936db1792a10ceac6547ae1503e", size = 789350, upload-time = "2026-05-09T23:14:34.799Z" }, + { url = "https://files.pythonhosted.org/packages/73/56/3dcafe34fc72e271d62ad9a291801e88a1457bb251c132f15fcc2e5aad1a/regex-2026.5.9-cp314-cp314-win32.whl", hash = "sha256:98bd73080e8756255137e1bd3f3f00295bbc5aa383c0e0f973920e9134d7c4ad", size = 272130, upload-time = "2026-05-09T23:14:36.729Z" }, + { url = "https://files.pythonhosted.org/packages/d0/9c/02eebf0be95efe416c664db7fb8b6b05b7a0b06a7544f2884f2558b0526f/regex-2026.5.9-cp314-cp314-win_amd64.whl", hash = "sha256:ff8d372ac2acdc048d1c19916f27ee61bc5722728458ba6ca5052f2c72d51763", size = 280999, upload-time = "2026-05-09T23:14:39.126Z" }, + { url = "https://files.pythonhosted.org/packages/70/5a/1dd1abee76cb7a846a0bcf42fdc87e5720c3c33c24f3e37814310a513d9f/regex-2026.5.9-cp314-cp314-win_arm64.whl", hash = "sha256:e1d93bf647916292e8edcec150c07ddf3dc50179ccaf770c04a7f9e452155372", size = 273500, upload-time = "2026-05-09T23:14:41.059Z" }, + { url = "https://files.pythonhosted.org/packages/86/c1/c5f619b0057a7965cb78ec559c1d7a45ce8c99a35bea95483d64959a93d9/regex-2026.5.9-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:83d0ee4a57d1c87cb549e195ec300b8f0ec3a82eba66d835e4e2ed8634fe4499", size = 494269, upload-time = "2026-05-09T23:14:42.869Z" }, + { url = "https://files.pythonhosted.org/packages/05/2c/5d01f1aee33de4bbe60c8452945bfc8477ca7c5ae4450f6bfe711036cb36/regex-2026.5.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:d3d7eb5c9a7f6df82ed3cfac9beb93882a5cbcb5b8b157b56cb2b3b276574ac1", size = 293954, upload-time = "2026-05-09T23:14:44.822Z" }, + { url = "https://files.pythonhosted.org/packages/7a/fe/e8988b2ae2108c6ef71bd4aa8d87fbe257976dd0810e826cd75f701c68b6/regex-2026.5.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:075160bf16658e16d35233300b8453aac25de4cbea808d22348b6979668e924d", size = 292405, upload-time = "2026-05-09T23:14:47.211Z" }, + { url = "https://files.pythonhosted.org/packages/79/34/d2b0937faa7859263f7f0a3c6b103a1296306be6952dc173d0154e9a2f49/regex-2026.5.9-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:45375819235558a4ff1c4971dc32881f022613abdb180128f5cb4768c1765a1c", size = 811855, upload-time = "2026-05-09T23:14:49.21Z" }, + { url = "https://files.pythonhosted.org/packages/80/fe/daf53a47457a8486db66c66c01ceb9c2303eecee3f87197f1e77eb1a736d/regex-2026.5.9-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ead4b163ac30a29574510cd4b3e2e985ac5290c05fc7095557d6a5f403fc31b5", size = 871189, upload-time = "2026-05-09T23:14:51.555Z" }, + { url = "https://files.pythonhosted.org/packages/1c/75/058fc4470cbfbf57d800aff1a0022b929a3f9fa553ee10a0cdf2070eb31f/regex-2026.5.9-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8c6e4218fbdfbcd4f6c19efca40930d24a621bf4b48cb76bc6640543bd28ef20", size = 917485, upload-time = "2026-05-09T23:14:53.633Z" }, + { url = "https://files.pythonhosted.org/packages/88/e7/179cfda3a28bc843b5c6cfe7f79f23489c791ed95f151083803660878432/regex-2026.5.9-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6351571c8a42b505eb555c0dc47d740d0fb66977dc142919eea6f4325b7c56a0", size = 816369, upload-time = "2026-05-09T23:14:56.198Z" }, + { url = "https://files.pythonhosted.org/packages/41/90/6f0cc422071688266d344fca8462d787cba0a2c144acb25721f9a61ec265/regex-2026.5.9-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:002205cafd2a9e78c6290c7d1df277bf3277b3b7a30e0b4bb0dac2e2e3f7cb2d", size = 785869, upload-time = "2026-05-09T23:14:58.602Z" }, + { url = "https://files.pythonhosted.org/packages/02/67/a31f1760f09c27b251ef39e9beb541f462cf977381d067faa764c2c0e393/regex-2026.5.9-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8abd33fef90b2a9efac5557d6033ca82d1195ed3a15fea5af15ba7b463c6a63b", size = 801427, upload-time = "2026-05-09T23:15:00.642Z" }, + { url = "https://files.pythonhosted.org/packages/e3/c4/1a80654597b6bc1e1ea0494824c31200e8a956abe290afae9b19a166a148/regex-2026.5.9-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:31037c82eccb44b7ea2e9e221d7c01429430e989a1f4b91ea5a855f6017b509a", size = 866482, upload-time = "2026-05-09T23:15:03.384Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/960724e06482c08466ff5611e242e86f80062949cdf6b4b9cc317b9dd93d/regex-2026.5.9-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:5604dfd046dc37eca90250fc3be938b076c8059fa772ac0ed6f499b0f0fb0415", size = 773022, upload-time = "2026-05-09T23:15:05.625Z" }, + { url = "https://files.pythonhosted.org/packages/50/a8/a9979c3e7918280e93159ebcab5ef1a65116dd4f3bd6091be0eae4a126e8/regex-2026.5.9-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0e1b1b4e496afbb24f4a62aba855ee4f88f25578927697b340702e48c9ee6bc2", size = 856642, upload-time = "2026-05-09T23:15:07.966Z" }, + { url = "https://files.pythonhosted.org/packages/fe/d4/a9b732f2f0072c0ab12227483abb24fffcb9f73f8a2b203df0a6d0434735/regex-2026.5.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:be3372b9df6ddecff6486d37e19095a7b4973137caf5512407a89f4455361f41", size = 803552, upload-time = "2026-05-09T23:15:10.215Z" }, + { url = "https://files.pythonhosted.org/packages/d5/fe/1b3113817447a1d4155e4ac76d2e072f42c0bcba2f43fa8a0e756ea2cd91/regex-2026.5.9-cp314-cp314t-win32.whl", hash = "sha256:3ddd90103f9e5c471c49c7852ecc1fe27c7e45eb99e977aefe7caa4e779f4f58", size = 275746, upload-time = "2026-05-09T23:15:12.609Z" }, + { url = "https://files.pythonhosted.org/packages/92/73/93d42045302636c91f2e5ef588b65b84b01428f28ec77de256b1dfdfbe5c/regex-2026.5.9-cp314-cp314t-win_amd64.whl", hash = "sha256:ca518ed29c46eecba6010b15f1b9a479314d2de409536e71b6a13aa04e3b8a77", size = 285685, upload-time = "2026-05-09T23:15:15.086Z" }, + { url = "https://files.pythonhosted.org/packages/da/80/35b4c33c804a165a7f55289afda3ea9e3eb6d15800341a2d66455c0f1f30/regex-2026.5.9-cp314-cp314t-win_arm64.whl", hash = "sha256:5e41809d2683fcde7d5a8c87a6567ba1fb1ce0de9f31bff578de00a4b2d76daa", size = 275713, upload-time = "2026-05-09T23:15:16.98Z" }, ] [[package]] @@ -5540,15 +5460,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/34/78/3cc84d58e13234861adf91d2897254cd84d3d4a90534d91c960b672e67d1/roifile-2026.2.10-py3-none-any.whl", hash = "sha256:5928a616b58a8ff1c9f89a0590db3616ccbf069c6692f8ecec2a7349f8bbb6ec", size = 21201, upload-time = "2026-02-11T19:54:34.137Z" }, ] -[[package]] -name = "roman-numerals" -version = "4.1.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ae/f9/41dc953bbeb056c17d5f7a519f50fdf010bd0553be2d630bc69d1e022703/roman_numerals-4.1.0.tar.gz", hash = "sha256:1af8b147eb1405d5839e78aeb93131690495fe9da5c91856cb33ad55a7f1e5b2", size = 9077, upload-time = "2025-12-17T18:25:34.381Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/04/54/6f679c435d28e0a568d8e8a7c0a93a09010818634c3c3907fc98d8983770/roman_numerals-4.1.0-py3-none-any.whl", hash = "sha256:647ba99caddc2cc1e55a51e4360689115551bf4476d90e8162cf8c345fe233c7", size = 7676, upload-time = "2025-12-17T18:25:33.098Z" }, -] - [[package]] name = "rpds-py" version = "2026.5.1" @@ -5599,6 +5510,64 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/8a/22/9bf80a56069c0c443fcfefac639a86a744550a2898817a6dfd3e26654924/rpds_py-2026.5.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e0b360f316d966b048b085857630b3cc51f3db2f07b06f440eac8f695374d1e3", size = 585633, upload-time = "2026-05-28T12:00:15.66Z" }, { url = "https://files.pythonhosted.org/packages/da/68/3b2c0a75c9e04125696f84ebdbbf304acf5a40b58ba4481cdb98a922c3ba/rpds_py-2026.5.1-cp313-cp313t-win32.whl", hash = "sha256:a2999883eedf72fdfb7520b92c7d4ec2572a71ff40239377aa604cc529eecafc", size = 210074, upload-time = "2026-05-28T12:00:17.291Z" }, { url = "https://files.pythonhosted.org/packages/e7/8b/609157d5a25d37d4f29f92840ba531f416907c34ae5c5739dd21fc2bef98/rpds_py-2026.5.1-cp313-cp313t-win_amd64.whl", hash = "sha256:e07be2a9d7122bd6e82dea89814ef8dc893feb1aae97fec1630f3263bbb30e55", size = 228635, upload-time = "2026-05-28T12:00:18.73Z" }, + { url = "https://files.pythonhosted.org/packages/d4/6f/19c1918a4b590d8de87e712e4abe4b3875771eff60216fb6153cf6665c68/rpds_py-2026.5.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:1f2c391c3059798093b65df23aca2cac150460ae9c630d99dec83d703d9485b9", size = 349756, upload-time = "2026-05-28T12:00:20.217Z" }, + { url = "https://files.pythonhosted.org/packages/e5/60/a06fe7da34eca79dacbf958a2ba0c6eea85bc2b29de20080bf40f72f66fa/rpds_py-2026.5.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:413b424f7c4ee65ab5e5be91f5731be0f8b41a1ee2b12dfe810d716312e95a78", size = 343831, upload-time = "2026-05-28T12:00:21.711Z" }, + { url = "https://files.pythonhosted.org/packages/bf/ec/b2333b97b90e2a6ef6ca8ad386ee284968e74bcfe113b3f1a8d9036429a9/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c595a1d9255dce0599e13130d1440ab2506654f2b50294226ee06402f8fef63", size = 375127, upload-time = "2026-05-28T12:00:23.326Z" }, + { url = "https://files.pythonhosted.org/packages/14/7f/e00aae54067f2b488c4637961d5f58204d470795fc791085fa3f15060d2e/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1c27c5f6102eac8c03e7595a00827a53b271ba40a53b59ff8709170e0855ea4a", size = 379034, upload-time = "2026-05-28T12:00:24.89Z" }, + { url = "https://files.pythonhosted.org/packages/be/cc/423999bbb8ae8dc93c77fc1d5e984ade5eb89d237d3bb884ccfa72ae2890/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6c7fcf61d44cacecaf3aea542b0e053db77972a4573e7ceda16fb2b399161195", size = 490823, upload-time = "2026-05-28T12:00:26.676Z" }, + { url = "https://files.pythonhosted.org/packages/0f/aa/c671bf660f12e68d3c52ff86c7066ed1372df5a0f4f2ff584e419b8207e7/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2c817a189d4ee14290420e5ff051e4dd6baa13f3edf84685071dee07a6d538ee", size = 388144, upload-time = "2026-05-28T12:00:28.577Z" }, + { url = "https://files.pythonhosted.org/packages/19/c8/d63bb75b68afe77b229e3021c6031bcaf01da5db5b0e69d0d10f9ba679a7/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21846aac0ed2e0589f38c12dc44e77bb64e494b771eadbcf169cba00566ba7ba", size = 371959, upload-time = "2026-05-28T12:00:30.304Z" }, + { url = "https://files.pythonhosted.org/packages/82/35/c51122014d8274ff37dc606d60049c3db7d83da02b5b282511e5a906a9a6/rpds_py-2026.5.1-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b317c87a13f769a4e787819bd508aaa5d69aa09b0880de9af6d3a8a54571cdec", size = 383558, upload-time = "2026-05-28T12:00:31.764Z" }, + { url = "https://files.pythonhosted.org/packages/e3/f9/2790cb99c136a5363acdeacf5c27c56f3de0d4118a1f48fca83404c99c89/rpds_py-2026.5.1-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ce87129d9f2c14fa6c4a8601fb80eb4488c80d38a20cd13758ef11123e14995d", size = 402789, upload-time = "2026-05-28T12:00:33.247Z" }, + { url = "https://files.pythonhosted.org/packages/e5/1b/e4fb584f8c75d35c38150ff6a332cda949e6f97acba1f4fd123b14ab56fe/rpds_py-2026.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9cdddb6c1207d284d94fd1530adf57fbd797fe7c4b8704ba85f49414f2557e7d", size = 551405, upload-time = "2026-05-28T12:00:34.819Z" }, + { url = "https://files.pythonhosted.org/packages/d8/f7/a6731b4216cb3793ea1af5391da240f5683dacc0d13e034fe5fc3503f240/rpds_py-2026.5.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:4e237e139f94d3c036fd28eb9f564c99055476ff4ff05cd42be55ce349b5aa02", size = 616975, upload-time = "2026-05-28T12:00:36.268Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/2e051a81d95d8e63f4b35a1c463a87e8766bc3d083c067c5dfb6bf220747/rpds_py-2026.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ed0954b524873214369184a9c82b0eaa45a3fbb9a798cd95b17e0d98499e7ea0", size = 578701, upload-time = "2026-05-28T12:00:37.82Z" }, + { url = "https://files.pythonhosted.org/packages/65/56/b5f6fdb2083e32bca8a8993d89e70db114b4756c9e2c38421328126689d2/rpds_py-2026.5.1-cp314-cp314-win32.whl", hash = "sha256:2d88621d6a7d4dfa633d21abe90f280bb205274e16b1d1e61c6ad4640b2453b7", size = 209806, upload-time = "2026-05-28T12:00:39.492Z" }, + { url = "https://files.pythonhosted.org/packages/fb/80/65a5aa96c155e611d1ed844e4e1f57f3e36b021f396d9f8585d756e6b90d/rpds_py-2026.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:cef8ac28d26f4dda3533060c20fbf80a325458fa9fd23ea72a73cdfa8e978838", size = 225985, upload-time = "2026-05-28T12:00:40.94Z" }, + { url = "https://files.pythonhosted.org/packages/27/7c/ad185212e87b05f196daef92bc5f3caf07298eb47c295b5585c3dd3093ac/rpds_py-2026.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:eaaea962c68cdc68d4a533ba985ab8e9484277910bbfaa2ab3ef7732667bfed8", size = 221219, upload-time = "2026-05-28T12:00:43.15Z" }, + { url = "https://files.pythonhosted.org/packages/23/58/e14ae18759020334646b031e708ab4158d653a938822bfb7b95ef2e93aa3/rpds_py-2026.5.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:21942f52dbbd5f8758bf021213d28bd45c39e873e65e2407faf5f1846f5761ad", size = 352148, upload-time = "2026-05-28T12:00:44.638Z" }, + { url = "https://files.pythonhosted.org/packages/31/9b/5f4a1e2f960bca3ac5d052b139dd31eed97b259f9d909173821760d542e8/rpds_py-2026.5.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f414556f6e3958300ff941e40c9f97e3dc9774ddd1b3434c475d73dd354bbed3", size = 345196, upload-time = "2026-05-28T12:00:46.14Z" }, + { url = "https://files.pythonhosted.org/packages/1a/71/1d9574d6a2fa20ab60eaa55c7467f5aa20cbc770f341a05f09c0876f59e2/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ef1013a8625c74043210190b246f5b1551e09757c1f356c6e4160ef96c5bc081", size = 374981, upload-time = "2026-05-28T12:00:47.531Z" }, + { url = "https://files.pythonhosted.org/packages/0c/9a/37e99f4915a80aa71670263c1267f7ae0af95f53a3f61e6c3bdc016d4515/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cc68e231a77a5f0d774ae278a1f8e55c0456501820847c1e4efb3829f3441df6", size = 379961, upload-time = "2026-05-28T12:00:49.216Z" }, + { url = "https://files.pythonhosted.org/packages/a8/ff/6e73f74b89d2e0715e0fc86b7dde893f9a61ae2f9b256ff3bdfe41ac4e94/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9baffb505aff33acc69b422a19f77806680f3c8632227d79f48de8a810d1c2c5", size = 495965, upload-time = "2026-05-28T12:00:51.111Z" }, + { url = "https://files.pythonhosted.org/packages/ea/e0/425faba25f59d74d4638b267f7c7a80e8649d2ef4db10a19b0c4a71e6e6f/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b8d2f912928d426e8cfa396f7f3f8d29a59e6689c86dcca3c420730c1096322b", size = 389526, upload-time = "2026-05-28T12:00:52.77Z" }, + { url = "https://files.pythonhosted.org/packages/c6/76/7a41960e3fddae47fab43a28684d5da981401dffd88253de0944148654cb/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90f628283be835db980c941767d41c9a27b5239e54ba0a9c1335247e82406964", size = 376190, upload-time = "2026-05-28T12:00:54.215Z" }, + { url = "https://files.pythonhosted.org/packages/27/60/5f38dc70824fc6951b51d35377e577a3a3a4c81a6769cc5a2de25ebe0ad1/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:1ebb2f0ab7e16132995a72de805170e0203df0c3dd22e1ef1cd1fdd90bd7a131", size = 383921, upload-time = "2026-05-28T12:00:55.673Z" }, + { url = "https://files.pythonhosted.org/packages/60/1a/d60a38caa1505f4b9483c3fbbde12c94e1079154f4f401a6da96f7e77621/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f3df3d16ded76f1f8c9cdebd0e1ea55fdf4c23b812de189814da7cf229c22a81", size = 404766, upload-time = "2026-05-28T12:00:57.518Z" }, + { url = "https://files.pythonhosted.org/packages/87/ff/602fd3f174d6425f0bce05ad0dfbec0e96b38d0f7d08a79af5aa20083885/rpds_py-2026.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9af8905b8f854990e40d5206aa5ac58d9b0fe0b7f351ff2bb086c20f6c8c6a47", size = 551343, upload-time = "2026-05-28T12:00:58.978Z" }, + { url = "https://files.pythonhosted.org/packages/b8/c1/1be13327acdbead3eca1fde03b6a34dbb011f1e864e217f0d32cc1779a7f/rpds_py-2026.5.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:036a36a87fb1cd3b214d11c4b3c4f7d2ddad933625dca1c900b56a057c07740a", size = 618502, upload-time = "2026-05-28T12:01:00.656Z" }, + { url = "https://files.pythonhosted.org/packages/f3/d7/afb49b49d7f2be8b7ba1a9f0977fa5168003437b93086726f066544e8351/rpds_py-2026.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:62ae3853454fe9ef283a03c96c2d835d39e84b14643a9d62c82ef0fb87d702ca", size = 581916, upload-time = "2026-05-28T12:01:02.22Z" }, + { url = "https://files.pythonhosted.org/packages/25/d1/dbef8c1f8a10f07beb62b5f054e20099fd9924b3ec001b8f0b6ac7813a85/rpds_py-2026.5.1-cp314-cp314t-win32.whl", hash = "sha256:6c3d771a46ec18b12af06ce36243a9a80b07a5d0515236332d90863ca8bb326a", size = 207855, upload-time = "2026-05-28T12:01:03.821Z" }, + { url = "https://files.pythonhosted.org/packages/2a/72/bfa4e61ab8e7dc1c8adf397e05e6cbdd4239357bd72b248d3de662f23915/rpds_py-2026.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c93c629be4636cf54337bd5f06c104d55e42ced54d681f6fe21ae510a65116f6", size = 225422, upload-time = "2026-05-28T12:01:05.194Z" }, + { url = "https://files.pythonhosted.org/packages/27/3a/7b5da92b640f67b6717ccafc83cdd06bfa7ff2395c3685c68922bb54d703/rpds_py-2026.5.1-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:3574b55c604b8f75dacb007136508bbc0db406e626301778096a133327e7f2fb", size = 349576, upload-time = "2026-05-28T12:01:06.722Z" }, + { url = "https://files.pythonhosted.org/packages/d7/8a/2aafd7ad355a1bd48ca76e2262b74b15e6432b5a1efe150efd4d779cd55d/rpds_py-2026.5.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:94068eb3ae6d43f5a786b7db96a406a34e6d5c24489feef32fd6e8946ea7b291", size = 343640, upload-time = "2026-05-28T12:01:08.441Z" }, + { url = "https://files.pythonhosted.org/packages/f7/7d/6c9523c1abbe840a1b7fba3c516d48e1d3487cc80fea4366c4071cf56784/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3a5b10e8ce894825f380a8f1b6444cf73c294dfea62afbb2d13e3a9e630cec1", size = 375322, upload-time = "2026-05-28T12:01:09.934Z" }, + { url = "https://files.pythonhosted.org/packages/5a/5d/0b7b03fb1dc509321f01de3149784ab773e34c8573022029af8076afcb9c/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fc09f82e63d4bcd58149572f857a431bae851dc747e313c3b5bdf7abb907fda8", size = 379066, upload-time = "2026-05-28T12:01:11.48Z" }, + { url = "https://files.pythonhosted.org/packages/d7/e2/8ef6012999ebf1cb1c22f876d9ce5e63d960fd4631d2af3202d3f480aa25/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e10464d17df3b582745c25cec695cb9558bca2cb6ddb631aee1787fc72c767b2", size = 494586, upload-time = "2026-05-28T12:01:13.051Z" }, + { url = "https://files.pythonhosted.org/packages/80/af/1eeb029bec67582c226b7809172207cd005073af4ebd906e65ff494f4983/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ba05adbf15d994c38ec0b7ab32e858e5110c21e9009a00a86545fd220f84e038", size = 388415, upload-time = "2026-05-28T12:01:14.631Z" }, + { url = "https://files.pythonhosted.org/packages/18/23/ffbe10711c4d766c1cab0557d6906c074f795814863c67b351355d29354a/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:77c004fdc7b891967106f78ddfd7b076bfe6813c6139c6fff6aed3bcaa960b26", size = 372427, upload-time = "2026-05-28T12:01:16.153Z" }, + { url = "https://files.pythonhosted.org/packages/bd/3a/30ba4a6ad457e5b070c18d742a33fb77d8d922b565cc881f8a5313d63bfe/rpds_py-2026.5.1-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:83bcf894486c9d78dd290d3c0124ff6dd8875d3025e2090a8ec49fcc37c55fdd", size = 383615, upload-time = "2026-05-28T12:01:17.809Z" }, + { url = "https://files.pythonhosted.org/packages/d3/69/62e242b53ce39c0814bd24e1a6e6eba6c92be716277745f317f9540a2e7b/rpds_py-2026.5.1-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c3df104083952a0e0c6f10de33e440eabe98fb6317d23e1a58c68f6df08d01b9", size = 402786, upload-time = "2026-05-28T12:01:19.419Z" }, + { url = "https://files.pythonhosted.org/packages/38/c1/a770b9c186928a1ed0f7e6d7ae50e7f3950ed23e3f9e366dbc8e38cb55de/rpds_py-2026.5.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:980450826cf22e133c57e0835070bdd0dd3f73b9b708c3ce223def2cb9469e14", size = 551583, upload-time = "2026-05-28T12:01:21.013Z" }, + { url = "https://files.pythonhosted.org/packages/21/7c/68e8579b95375b70d2a963103c42e705856cdb98569258bd807f4423891c/rpds_py-2026.5.1-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:205dde846f24332ab0c1188699a043b8d165b79bb84529ce272c45048ff6be01", size = 616941, upload-time = "2026-05-28T12:01:22.548Z" }, + { url = "https://files.pythonhosted.org/packages/70/a1/a6135aed5730ff03ab957182259987ac11e55fb392a28dc6f0592048a280/rpds_py-2026.5.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:3966b82dd563176396df030f3dd52a6e54cb69b718e95e78bd555ed3d1e0185d", size = 578349, upload-time = "2026-05-28T12:01:24.118Z" }, + { url = "https://files.pythonhosted.org/packages/09/6e/f24201a76a84e6c49d0bdfdfcb735210e21701e9b21c5bfc0ba497dd62f6/rpds_py-2026.5.1-cp315-cp315-win32.whl", hash = "sha256:7818f8d0a415be74d2be3590b0a1c1f463a642f4d0217e7d10602dceef5b79aa", size = 209922, upload-time = "2026-05-28T12:01:25.522Z" }, + { url = "https://files.pythonhosted.org/packages/9e/e4/966bc240bb0485fc265278f6de44d05834bf0b3618886e0b22e33d54c49a/rpds_py-2026.5.1-cp315-cp315-win_amd64.whl", hash = "sha256:b3cc20c0d800af78fd0fac68086e28c1856cec51ea528bb81ea851aa40d39325", size = 226003, upload-time = "2026-05-28T12:01:27.062Z" }, + { url = "https://files.pythonhosted.org/packages/5c/5c/a15a59269cd5e74472734516c73795c15eccfc841b3d4b0228c3f53f19d0/rpds_py-2026.5.1-cp315-cp315-win_arm64.whl", hash = "sha256:3609e9939a8a76cd904cf98a3f1f13b5dc7e150adeaee89e0ea09652ea213e16", size = 221245, upload-time = "2026-05-28T12:01:28.51Z" }, + { url = "https://files.pythonhosted.org/packages/e0/22/135ce03804e179a71ceb13be095deda4a279bc88f7a6b8fa161c5ad44e12/rpds_py-2026.5.1-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:5d333a7127d4b307601ac37792bee01bb95c867cbfacf21b6375b804d6bbd723", size = 352015, upload-time = "2026-05-28T12:01:30.214Z" }, + { url = "https://files.pythonhosted.org/packages/3b/5f/f1f6d2652eb9d848f6eb369d8db83a2da6249bb49ad2c2a48f45d54538d3/rpds_py-2026.5.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:b5f077b44a4f7808520f66dae234988d867deb9aed9be5da057ce9ba831b2a41", size = 345016, upload-time = "2026-05-28T12:01:31.656Z" }, + { url = "https://files.pythonhosted.org/packages/88/66/b74182775691ea2290c99e52ac8d5db844e56fbec90ce421f107658c8314/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55d8f9b7b78c9538fc9e04e82ec0e888ff0c3cffcfad152c77e57cd09351a98a", size = 374775, upload-time = "2026-05-28T12:01:33.136Z" }, + { url = "https://files.pythonhosted.org/packages/ff/8f/15e5a61d9f0a43902d36561d4f07cae6ae9f4716be825159fd72717f33af/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e3a8ae58895ac107ed934a6bf51e5846f95c53b9b940c2c6d310838fd5846358", size = 380270, upload-time = "2026-05-28T12:01:34.574Z" }, + { url = "https://files.pythonhosted.org/packages/02/c3/f859b12763a80540cdf2af0f15b19904cf756a71d7bdd3f82ff3e5b1bbf9/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0957cf3c2b8632ec7aaebffebea8005b353cc2a237b6e2ae3c2cac0820704cfb", size = 495285, upload-time = "2026-05-28T12:01:36.127Z" }, + { url = "https://files.pythonhosted.org/packages/1c/c7/ff27c2ac8411d30b03b1829fd88cae8dad1a4d0da48dd25e57c4038042e6/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c396c1304de421050b3681ea70f371874b54d41b0151e96109758144c231e30b", size = 389581, upload-time = "2026-05-28T12:01:37.635Z" }, + { url = "https://files.pythonhosted.org/packages/6e/67/fe92ee32a6cc05c77228a2f8b1762e7124f386ec20ff83d0757b762d58d0/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aad1bff7f666b9598e573815affd666aac6a13a585dde336f843e33350c7fadc", size = 376041, upload-time = "2026-05-28T12:01:39.307Z" }, + { url = "https://files.pythonhosted.org/packages/f8/91/b4d6685c27aba55bd82f25b278be8237038117d05f9659a6213ad3408130/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:656a042550878f12d45752452d47094b7cfe5ad1e9d7b87b5a22ad3ae5ff8015", size = 383946, upload-time = "2026-05-28T12:01:41.043Z" }, + { url = "https://files.pythonhosted.org/packages/bd/79/2c1d832a53c8e0f8e98fc970ec257b950fecd4f62be2ab7182b500a0cbc8/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:73c4bd4f70294737b5206a3e8e30ccadbf8a60301831c8ea23eec5dbeea1ecfa", size = 405526, upload-time = "2026-05-28T12:01:43.032Z" }, + { url = "https://files.pythonhosted.org/packages/78/c4/c98117b03c6a8581ab2c2dfccfe9a5ad82bd8128a3c28b46a6ad2d97c393/rpds_py-2026.5.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:43bca78665423cabae77146f2fe7ce55272b6c8d55d82cca83effd42c7e13972", size = 551165, upload-time = "2026-05-28T12:01:44.648Z" }, + { url = "https://files.pythonhosted.org/packages/3b/c1/bc479ca069200af730881b1bd525e3114b2b391a351509fcb1b772f28086/rpds_py-2026.5.1-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:42d0f20e85e549c870749d0e247f0c10d318a45b7e9676d575d2dcb04a1b2e66", size = 618778, upload-time = "2026-05-28T12:01:46.337Z" }, + { url = "https://files.pythonhosted.org/packages/77/65/38ab2f90df44c2febfb63cc10ced40763d9b4bc94d173e734528663fe7f5/rpds_py-2026.5.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:b1be5c35683684d5331b93600c210e8367c254683d8a6df6bd21bd2da3a334fb", size = 581839, upload-time = "2026-05-28T12:01:48.109Z" }, + { url = "https://files.pythonhosted.org/packages/15/2d/ce1f605fe036aadd460e5822e578c6c7ec3a860936cca37d6e0f299daa77/rpds_py-2026.5.1-cp315-cp315t-win32.whl", hash = "sha256:75808f6c38ce7749bb68cc2770161aae5045e6c6f6781a9782e74b93304399df", size = 207866, upload-time = "2026-05-28T12:01:49.648Z" }, + { url = "https://files.pythonhosted.org/packages/79/cb/966040123eb102371559746908ef2c9471f4d43e17ec9a645a2258dab64b/rpds_py-2026.5.1-cp315-cp315t-win_amd64.whl", hash = "sha256:90bd6630002a1c7f09e7843dd79f0d24f3d2897cc25a753480917865d14f15b3", size = 225441, upload-time = "2026-05-28T12:01:51.408Z" }, ] [[package]] @@ -5623,30 +5592,16 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a9/ec/cee878c1879b91ab8dc7d564535d011307839a2fea79d2a650413edf53be/rustworkx-0.17.1-cp39-abi3-win_amd64.whl", hash = "sha256:d0a48fb62adabd549f9f02927c3a159b51bf654c7388a12fc16d45452d5703ea", size = 2055049, upload-time = "2025-08-13T01:43:44.926Z" }, ] -[[package]] -name = "s3fs" -version = "2026.4.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "aiobotocore" }, - { name = "aiohttp" }, - { name = "fsspec" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/cb/d8/76f3dc1558bdf4494b117a9f7a9cc0a5d9d34edadc9e5d7ceabc5a6a7c37/s3fs-2026.4.0.tar.gz", hash = "sha256:5bdce0abb00b0435ee150807a45fea727451dbc22de4cbc116464f8504ab9d37", size = 85986, upload-time = "2026-04-29T20:52:51.748Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/5d/a4/9d1ea10ebc9e028a289a72fec84da170689549a8102c8aacfcad26bc5035/s3fs-2026.4.0-py3-none-any.whl", hash = "sha256:de0d2a1f33cdf03831fd2382d278c6e4e31fe57c3bf2f703c61f8aec6b703e2a", size = 32392, upload-time = "2026-04-29T20:52:50.295Z" }, -] - [[package]] name = "s3transfer" -version = "0.17.1" +version = "0.18.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "botocore" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/11/b3/bcdc2f58fa92592db511beda154c2c08d28f21f6c4637f06a42a24b10c21/s3transfer-0.17.1.tar.gz", hash = "sha256:042dd5e3b1b512355e35a23f0223e426b7042e80b97830ea2680ddce327fc45e", size = 159439, upload-time = "2026-05-26T19:45:01.714Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/1f/12417f7f493fc45e1f9fd5d4a9b6c125cf8d2cf3f8ddbdfab3e76406e9d6/s3transfer-0.18.0.tar.gz", hash = "sha256:3760b8b7ec1315da54048b2d626276732bee4300d054d492d4e1d43e20d4ecbd", size = 160560, upload-time = "2026-05-28T19:39:09.124Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/85/dd/904873250a6554fbae40cddbf9198e3cc37a2f1319d5e1a5ce82fe269c17/s3transfer-0.17.1-py3-none-any.whl", hash = "sha256:5b9827d1044159bbb01b86ef8902760ea39281927f5de31de75e1d657177bf4c", size = 88264, upload-time = "2026-05-26T19:45:00.452Z" }, + { url = "https://files.pythonhosted.org/packages/2b/58/a58fc997655386daa2e25784e30c288aa3e3819e401f77029ee4899fb55a/s3transfer-0.18.0-py3-none-any.whl", hash = "sha256:239c13b09e65ad0346e1be7348b8a202dcad44ac7ea7c6eb858fc881dce739b6", size = 88572, upload-time = "2026-05-28T19:39:07.999Z" }, ] [[package]] @@ -5711,11 +5666,22 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/02/94/9f46966fa042b5d57c8cd641045372b4e0df0047dd400e77ea9952674110/scikit_image-0.26.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:20ef4a155e2e78b8ab973998e04d8a361d49d719e65412405f4dadd9155a61d9", size = 14359526, upload-time = "2025-12-20T17:11:41.087Z" }, { url = "https://files.pythonhosted.org/packages/5d/b4/2840fe38f10057f40b1c9f8fb98a187a370936bf144a4ac23452c5ef1baf/scikit_image-0.26.0-cp313-cp313t-win_amd64.whl", hash = "sha256:c9087cf7d0e7f33ab5c46d2068d86d785e70b05400a891f73a13400f1e1faf6a", size = 12287629, upload-time = "2025-12-20T17:11:43.11Z" }, { url = "https://files.pythonhosted.org/packages/22/ba/73b6ca70796e71f83ab222690e35a79612f0117e5aaf167151b7d46f5f2c/scikit_image-0.26.0-cp313-cp313t-win_arm64.whl", hash = "sha256:27d58bc8b2acd351f972c6508c1b557cfed80299826080a4d803dd29c51b707e", size = 11647755, upload-time = "2025-12-20T17:11:45.279Z" }, -] - -[package.optional-dependencies] -data = [ - { name = "pooch" }, + { url = "https://files.pythonhosted.org/packages/51/44/6b744f92b37ae2833fd423cce8f806d2368859ec325a699dc30389e090b9/scikit_image-0.26.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:63af3d3a26125f796f01052052f86806da5b5e54c6abef152edb752683075a9c", size = 12365810, upload-time = "2025-12-20T17:11:47.357Z" }, + { url = "https://files.pythonhosted.org/packages/40/f5/83590d9355191f86ac663420fec741b82cc547a4afe7c4c1d986bf46e4db/scikit_image-0.26.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ce00600cd70d4562ed59f80523e18cdcc1fae0e10676498a01f73c255774aefd", size = 12075717, upload-time = "2025-12-20T17:11:49.483Z" }, + { url = "https://files.pythonhosted.org/packages/72/48/253e7cf5aee6190459fe136c614e2cbccc562deceb4af96e0863f1b8ee29/scikit_image-0.26.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6381edf972b32e4f54085449afde64365a57316637496c1325a736987083e2ab", size = 13161520, upload-time = "2025-12-20T17:11:51.58Z" }, + { url = "https://files.pythonhosted.org/packages/73/c3/cec6a3cbaadfdcc02bd6ff02f3abfe09eaa7f4d4e0a525a1e3a3f4bce49c/scikit_image-0.26.0-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6624a76c6085218248154cc7e1500e6b488edcd9499004dd0d35040607d7505", size = 13684340, upload-time = "2025-12-20T17:11:53.708Z" }, + { url = "https://files.pythonhosted.org/packages/d4/0d/39a776f675d24164b3a267aa0db9f677a4cb20127660d8bf4fd7fef66817/scikit_image-0.26.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f775f0e420faac9c2aa6757135f4eb468fb7b70e0b67fa77a5e79be3c30ee331", size = 14203839, upload-time = "2025-12-20T17:11:55.89Z" }, + { url = "https://files.pythonhosted.org/packages/ee/25/2514df226bbcedfe9b2caafa1ba7bc87231a0c339066981b182b08340e06/scikit_image-0.26.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ede4d6d255cc5da9faeb2f9ba7fedbc990abbc652db429f40a16b22e770bb578", size = 14770021, upload-time = "2025-12-20T17:11:58.014Z" }, + { url = "https://files.pythonhosted.org/packages/8d/5b/0671dc91c0c79340c3fe202f0549c7d3681eb7640fe34ab68a5f090a7c7f/scikit_image-0.26.0-cp314-cp314-win_amd64.whl", hash = "sha256:0660b83968c15293fd9135e8d860053ee19500d52bf55ca4fb09de595a1af650", size = 12023490, upload-time = "2025-12-20T17:12:00.013Z" }, + { url = "https://files.pythonhosted.org/packages/65/08/7c4cb59f91721f3de07719085212a0b3962e3e3f2d1818cbac4eeb1ea53e/scikit_image-0.26.0-cp314-cp314-win_arm64.whl", hash = "sha256:b8d14d3181c21c11170477a42542c1addc7072a90b986675a71266ad17abc37f", size = 11473782, upload-time = "2025-12-20T17:12:01.983Z" }, + { url = "https://files.pythonhosted.org/packages/49/41/65c4258137acef3d73cb561ac55512eacd7b30bb4f4a11474cad526bc5db/scikit_image-0.26.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:cde0bbd57e6795eba83cb10f71a677f7239271121dc950bc060482834a668ad1", size = 12686060, upload-time = "2025-12-20T17:12:03.886Z" }, + { url = "https://files.pythonhosted.org/packages/e7/32/76971f8727b87f1420a962406388a50e26667c31756126444baf6668f559/scikit_image-0.26.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:163e9afb5b879562b9aeda0dd45208a35316f26cc7a3aed54fd601604e5cf46f", size = 12422628, upload-time = "2025-12-20T17:12:05.921Z" }, + { url = "https://files.pythonhosted.org/packages/37/0d/996febd39f757c40ee7b01cdb861867327e5c8e5f595a634e8201462d958/scikit_image-0.26.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:724f79fd9b6cb6f4a37864fe09f81f9f5d5b9646b6868109e1b100d1a7019e59", size = 12962369, upload-time = "2025-12-20T17:12:07.912Z" }, + { url = "https://files.pythonhosted.org/packages/48/b4/612d354f946c9600e7dea012723c11d47e8d455384e530f6daaaeb9bf62c/scikit_image-0.26.0-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3268f13310e6857508bd87202620df996199a016a1d281b309441d227c822394", size = 13272431, upload-time = "2025-12-20T17:12:10.255Z" }, + { url = "https://files.pythonhosted.org/packages/0a/6e/26c00b466e06055a086de2c6e2145fe189ccdc9a1d11ccc7de020f2591ad/scikit_image-0.26.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fac96a1f9b06cd771cbbb3cd96c5332f36d4efd839b1d8b053f79e5887acde62", size = 14016362, upload-time = "2025-12-20T17:12:12.793Z" }, + { url = "https://files.pythonhosted.org/packages/47/88/00a90402e1775634043c2a0af8a3c76ad450866d9fa444efcc43b553ba2d/scikit_image-0.26.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2c1e7bd342f43e7a97e571b3f03ba4c1293ea1a35c3f13f41efdc8a81c1dc8f2", size = 14364151, upload-time = "2025-12-20T17:12:14.909Z" }, + { url = "https://files.pythonhosted.org/packages/da/ca/918d8d306bd43beacff3b835c6d96fac0ae64c0857092f068b88db531a7c/scikit_image-0.26.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b702c3bb115e1dcf4abf5297429b5c90f2189655888cbed14921f3d26f81d3a4", size = 12413484, upload-time = "2025-12-20T17:12:17.046Z" }, + { url = "https://files.pythonhosted.org/packages/dc/cd/4da01329b5a8d47ff7ec3c99a2b02465a8017b186027590dc7425cee0b56/scikit_image-0.26.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0608aa4a9ec39e0843de10d60edb2785a30c1c47819b67866dd223ebd149acaf", size = 11769501, upload-time = "2025-12-20T17:12:19.339Z" }, ] [[package]] @@ -5743,6 +5709,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/1f/88/8dab5de10c638c083772a6be83a3d8106ced492f74a928c8693638e5bb50/scikit_learn-1.9.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:da76d09304a4706db7cc1e3ebaa3b6b98a67365cc11d2996c4f1e58ba47df714", size = 9087723, upload-time = "2026-06-02T11:53:50.702Z" }, { url = "https://files.pythonhosted.org/packages/20/3f/7917ca72464038f6240ec70c29f94862d08a34a74291ae4d4ec5eb8186a0/scikit_learn-1.9.0-cp313-cp313-win_amd64.whl", hash = "sha256:5808d98f15c6bf6d9d96d2348c1997392a5888ce7097e664105f930c4bca1277", size = 8184330, upload-time = "2026-06-02T11:53:53.396Z" }, { url = "https://files.pythonhosted.org/packages/78/c7/15739eb2f61fda3c54639e9942414e5a19ad8a8d1f5a3266afad7cb7df80/scikit_learn-1.9.0-cp313-cp313-win_arm64.whl", hash = "sha256:d77f54c017633791bc0225a43e2f8d03745fdcfe4880268fcc4df15f505dec2e", size = 7840653, upload-time = "2026-06-02T11:53:56.035Z" }, + { url = "https://files.pythonhosted.org/packages/f4/7d/c9a35cf59b20a86fec24d306f1547b78dec194b08d367ce2a3e4854169d9/scikit_learn-1.9.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:9656acd4e93f74e0b66c8a36c88830a99252dfa900044d36bc2212ae89a47162", size = 8713289, upload-time = "2026-06-02T11:53:58.788Z" }, + { url = "https://files.pythonhosted.org/packages/3c/a7/552a7821597c632b907f7bfe8f36f9f572777af8ef8a48353041cf8e091a/scikit_learn-1.9.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:24360002ae845e7866522b0a5bbf690802e7bc388cac8663502e78aa98598aa2", size = 8245141, upload-time = "2026-06-02T11:54:01.694Z" }, + { url = "https://files.pythonhosted.org/packages/7d/79/f4a0c4fe9711154cddabf913471153af79056382ddc612cfe5ee0ff4b72e/scikit_learn-1.9.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5162ad10a418c8a282dde04c9aa06965de3e9a65f33c1440c0ae69bb1a09d913", size = 8847671, upload-time = "2026-06-02T11:54:04.448Z" }, + { url = "https://files.pythonhosted.org/packages/f0/af/4d72d9e475ac83719160c662619e4bf7b95c19507cd582e7d0167a3c3dae/scikit_learn-1.9.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fea2cc5677ab49d6f5bade978c866da44957b712d92e9635e8b4f723013c3cb", size = 9118104, upload-time = "2026-06-02T11:54:07.205Z" }, + { url = "https://files.pythonhosted.org/packages/a2/d5/6a58eea2cb9abbb9b3f2bb8b2cfb3243d1152d69f442d256c7af71304769/scikit_learn-1.9.0-cp314-cp314-win_amd64.whl", hash = "sha256:64fa347efc1c839c487433e40c5144d38c336e8a2b59c81aa8660373945c2673", size = 8290674, upload-time = "2026-06-02T11:54:10.087Z" }, + { url = "https://files.pythonhosted.org/packages/65/5b/d4c879cf358f1187141cf90ced473f087183489090244f50c124a2ee478b/scikit_learn-1.9.0-cp314-cp314-win_arm64.whl", hash = "sha256:1b944b6db288f6b926e3650026ddafb988929de95d11fc2cc5fa117773c9ba42", size = 7978807, upload-time = "2026-06-02T11:54:12.769Z" }, + { url = "https://files.pythonhosted.org/packages/8a/43/bfae3121ec67ae09150d453c442c7c1cc166e9aefe056e6ab3b7728a5cfc/scikit_learn-1.9.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:4ccacf04ca5f4b492158a5f28afe0ace43f81b2571e4b9a66d34848b46128949", size = 9031941, upload-time = "2026-06-02T11:54:15.436Z" }, + { url = "https://files.pythonhosted.org/packages/75/b0/20a4546eb17f3b25d3c66df15810411c14ed5065bcfab50b53c96fb627b2/scikit_learn-1.9.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:ee1a8db2c18c08e34c7412d4b10be1cac214cd4ea7dc9715a6a327eb49a37c96", size = 8613528, upload-time = "2026-06-02T11:54:18.842Z" }, + { url = "https://files.pythonhosted.org/packages/18/3c/e440e039bb82cd19004edaaad00acbde0fb9b461083c3ecf37941c557312/scikit_learn-1.9.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:147e9329ef0e39f75d4cffa02b2aa48d827832684926cd5210d9a2cb5c57246b", size = 8855050, upload-time = "2026-06-02T11:54:21.699Z" }, + { url = "https://files.pythonhosted.org/packages/43/26/b341b8dab5998da6270a3a42c2152c578501354d36f944b5856757035ef8/scikit_learn-1.9.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bad8f8b9950321b54c965fdcbac6c6c55e79e16646b49977bcf3668d3870a1a", size = 9097190, upload-time = "2026-06-02T11:54:24.454Z" }, + { url = "https://files.pythonhosted.org/packages/fb/de/b650b4d69b84468cfa2e28a3ff7b8103743029e6446ce1a97fe060ef688c/scikit_learn-1.9.0-cp314-cp314t-win_amd64.whl", hash = "sha256:78fc56eafd4edb9575d2d8950d1dd152061abb573341a1cb7e099fc40f6c6666", size = 8963204, upload-time = "2026-06-02T11:54:27.428Z" }, + { url = "https://files.pythonhosted.org/packages/ee/f3/ff83d76d7418112e5a61326443cdda87be3545dd8d6599c95b2481a4419e/scikit_learn-1.9.0-cp314-cp314t-win_arm64.whl", hash = "sha256:051075bda8b7aab87b1906ab3d4740a1e1224a19d7b3781a576736edc94e76aa", size = 8222661, upload-time = "2026-06-02T11:54:30.192Z" }, ] [[package]] @@ -5784,6 +5762,26 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/bd/12/d19da97efde68ca1ee5538bb261d5d2c062f0c055575128f11a2730e3ac1/scipy-1.17.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:94055a11dfebe37c656e70317e1996dc197e1a15bbcc351bcdd4610e128fe1ca", size = 37665910, upload-time = "2026-02-23T00:20:34.743Z" }, { url = "https://files.pythonhosted.org/packages/06/1c/1172a88d507a4baaf72c5a09bb6c018fe2ae0ab622e5830b703a46cc9e44/scipy-1.17.1-cp313-cp313t-win_amd64.whl", hash = "sha256:e30bdeaa5deed6bc27b4cc490823cd0347d7dae09119b8803ae576ea0ce52e4c", size = 36562980, upload-time = "2026-02-23T00:20:40.575Z" }, { url = "https://files.pythonhosted.org/packages/70/b0/eb757336e5a76dfa7911f63252e3b7d1de00935d7705cf772db5b45ec238/scipy-1.17.1-cp313-cp313t-win_arm64.whl", hash = "sha256:a720477885a9d2411f94a93d16f9d89bad0f28ca23c3f8daa521e2dcc3f44d49", size = 24856543, upload-time = "2026-02-23T00:20:45.313Z" }, + { url = "https://files.pythonhosted.org/packages/cf/83/333afb452af6f0fd70414dc04f898647ee1423979ce02efa75c3b0f2c28e/scipy-1.17.1-cp314-cp314-macosx_10_14_x86_64.whl", hash = "sha256:a48a72c77a310327f6a3a920092fa2b8fd03d7deaa60f093038f22d98e096717", size = 31584510, upload-time = "2026-02-23T00:21:01.015Z" }, + { url = "https://files.pythonhosted.org/packages/ed/a6/d05a85fd51daeb2e4ea71d102f15b34fedca8e931af02594193ae4fd25f7/scipy-1.17.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:45abad819184f07240d8a696117a7aacd39787af9e0b719d00285549ed19a1e9", size = 28170131, upload-time = "2026-02-23T00:21:05.888Z" }, + { url = "https://files.pythonhosted.org/packages/db/7b/8624a203326675d7746a254083a187398090a179335b2e4a20e2ddc46e83/scipy-1.17.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:3fd1fcdab3ea951b610dc4cef356d416d5802991e7e32b5254828d342f7b7e0b", size = 20342032, upload-time = "2026-02-23T00:21:09.904Z" }, + { url = "https://files.pythonhosted.org/packages/c9/35/2c342897c00775d688d8ff3987aced3426858fd89d5a0e26e020b660b301/scipy-1.17.1-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:7bdf2da170b67fdf10bca777614b1c7d96ae3ca5794fd9587dce41eb2966e866", size = 22678766, upload-time = "2026-02-23T00:21:14.313Z" }, + { url = "https://files.pythonhosted.org/packages/ef/f2/7cdb8eb308a1a6ae1e19f945913c82c23c0c442a462a46480ce487fdc0ac/scipy-1.17.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:adb2642e060a6549c343603a3851ba76ef0b74cc8c079a9a58121c7ec9fe2350", size = 32957007, upload-time = "2026-02-23T00:21:19.663Z" }, + { url = "https://files.pythonhosted.org/packages/0b/2e/7eea398450457ecb54e18e9d10110993fa65561c4f3add5e8eccd2b9cd41/scipy-1.17.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eee2cfda04c00a857206a4330f0c5e3e56535494e30ca445eb19ec624ae75118", size = 35221333, upload-time = "2026-02-23T00:21:25.278Z" }, + { url = "https://files.pythonhosted.org/packages/d9/77/5b8509d03b77f093a0d52e606d3c4f79e8b06d1d38c441dacb1e26cacf46/scipy-1.17.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d2650c1fb97e184d12d8ba010493ee7b322864f7d3d00d3f9bb97d9c21de4068", size = 35042066, upload-time = "2026-02-23T00:21:31.358Z" }, + { url = "https://files.pythonhosted.org/packages/f9/df/18f80fb99df40b4070328d5ae5c596f2f00fffb50167e31439e932f29e7d/scipy-1.17.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:08b900519463543aa604a06bec02461558a6e1cef8fdbb8098f77a48a83c8118", size = 37612763, upload-time = "2026-02-23T00:21:37.247Z" }, + { url = "https://files.pythonhosted.org/packages/4b/39/f0e8ea762a764a9dc52aa7dabcfad51a354819de1f0d4652b6a1122424d6/scipy-1.17.1-cp314-cp314-win_amd64.whl", hash = "sha256:3877ac408e14da24a6196de0ddcace62092bfc12a83823e92e49e40747e52c19", size = 37290984, upload-time = "2026-02-23T00:22:35.023Z" }, + { url = "https://files.pythonhosted.org/packages/7c/56/fe201e3b0f93d1a8bcf75d3379affd228a63d7e2d80ab45467a74b494947/scipy-1.17.1-cp314-cp314-win_arm64.whl", hash = "sha256:f8885db0bc2bffa59d5c1b72fad7a6a92d3e80e7257f967dd81abb553a90d293", size = 25192877, upload-time = "2026-02-23T00:22:39.798Z" }, + { url = "https://files.pythonhosted.org/packages/96/ad/f8c414e121f82e02d76f310f16db9899c4fcde36710329502a6b2a3c0392/scipy-1.17.1-cp314-cp314t-macosx_10_14_x86_64.whl", hash = "sha256:1cc682cea2ae55524432f3cdff9e9a3be743d52a7443d0cba9017c23c87ae2f6", size = 31949750, upload-time = "2026-02-23T00:21:42.289Z" }, + { url = "https://files.pythonhosted.org/packages/7c/b0/c741e8865d61b67c81e255f4f0a832846c064e426636cd7de84e74d209be/scipy-1.17.1-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:2040ad4d1795a0ae89bfc7e8429677f365d45aa9fd5e4587cf1ea737f927b4a1", size = 28585858, upload-time = "2026-02-23T00:21:47.706Z" }, + { url = "https://files.pythonhosted.org/packages/ed/1b/3985219c6177866628fa7c2595bfd23f193ceebbe472c98a08824b9466ff/scipy-1.17.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:131f5aaea57602008f9822e2115029b55d4b5f7c070287699fe45c661d051e39", size = 20757723, upload-time = "2026-02-23T00:21:52.039Z" }, + { url = "https://files.pythonhosted.org/packages/c0/19/2a04aa25050d656d6f7b9e7b685cc83d6957fb101665bfd9369ca6534563/scipy-1.17.1-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:9cdc1a2fcfd5c52cfb3045feb399f7b3ce822abdde3a193a6b9a60b3cb5854ca", size = 23043098, upload-time = "2026-02-23T00:21:56.185Z" }, + { url = "https://files.pythonhosted.org/packages/86/f1/3383beb9b5d0dbddd030335bf8a8b32d4317185efe495374f134d8be6cce/scipy-1.17.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e3dcd57ab780c741fde8dc68619de988b966db759a3c3152e8e9142c26295ad", size = 33030397, upload-time = "2026-02-23T00:22:01.404Z" }, + { url = "https://files.pythonhosted.org/packages/41/68/8f21e8a65a5a03f25a79165ec9d2b28c00e66dc80546cf5eb803aeeff35b/scipy-1.17.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a9956e4d4f4a301ebf6cde39850333a6b6110799d470dbbb1e25326ac447f52a", size = 35281163, upload-time = "2026-02-23T00:22:07.024Z" }, + { url = "https://files.pythonhosted.org/packages/84/8d/c8a5e19479554007a5632ed7529e665c315ae7492b4f946b0deb39870e39/scipy-1.17.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:a4328d245944d09fd639771de275701ccadf5f781ba0ff092ad141e017eccda4", size = 35116291, upload-time = "2026-02-23T00:22:12.585Z" }, + { url = "https://files.pythonhosted.org/packages/52/52/e57eceff0e342a1f50e274264ed47497b59e6a4e3118808ee58ddda7b74a/scipy-1.17.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a77cbd07b940d326d39a1d1b37817e2ee4d79cb30e7338f3d0cddffae70fcaa2", size = 37682317, upload-time = "2026-02-23T00:22:18.513Z" }, + { url = "https://files.pythonhosted.org/packages/11/2f/b29eafe4a3fbc3d6de9662b36e028d5f039e72d345e05c250e121a230dd4/scipy-1.17.1-cp314-cp314t-win_amd64.whl", hash = "sha256:eb092099205ef62cd1782b006658db09e2fed75bffcae7cc0d44052d8aa0f484", size = 37345327, upload-time = "2026-02-23T00:22:24.442Z" }, + { url = "https://files.pythonhosted.org/packages/07/39/338d9219c4e87f3e708f18857ecd24d22a0c3094752393319553096b98af/scipy-1.17.1-cp314-cp314t-win_arm64.whl", hash = "sha256:200e1050faffacc162be6a486a984a0497866ec54149a01270adc8a59b7c7d21", size = 25489165, upload-time = "2026-02-23T00:22:29.563Z" }, ] [[package]] @@ -5883,15 +5881,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c1/d4/59e74daffcb57a07668852eeeb6035af9f32cbfd7a1d2511f17d2fe6a738/smmap-5.0.3-py3-none-any.whl", hash = "sha256:c106e05d5a61449cf6ba9a1e650227ecfb141590d2a98412103ff35d89fc7b2f", size = 24390, upload-time = "2026-03-09T03:43:24.361Z" }, ] -[[package]] -name = "snowballstemmer" -version = "3.1.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/43/f8/0a71edf031f03c40db17503cb8ca78a69a171254e568e7db241b0ab57ea1/snowballstemmer-3.1.1.tar.gz", hash = "sha256:e07bbc54a0d798fe6010a12398422e62a8bfbba95c394fd0956ef58cb4d3e260", size = 123314, upload-time = "2026-06-03T00:56:40.194Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/4c/07/2ebca9b11fb9be7340a818d8d6f63feaebb146be2c4afbd6061701d6df6e/snowballstemmer-3.1.1-py3-none-any.whl", hash = "sha256:7e207fa178741da09cdee59d3ecec3827ad5f92b1fc5c9ff3755b639f71f5752", size = 104164, upload-time = "2026-06-03T00:56:38.614Z" }, -] - [[package]] name = "sortedcontainers" version = "2.4.0" @@ -5910,104 +5899,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/5e/f5/0c41cb68dcae6b7de4fac4188a3a9589e21fb31df21ea3a2e888db95e6c9/soupsieve-2.8.4-py3-none-any.whl", hash = "sha256:e7e6b0769c8f51ed59acab6e994b00621096cfb1c640a7509295987388fbaf65", size = 37304, upload-time = "2026-05-24T13:55:55.406Z" }, ] -[[package]] -name = "spatial-graph" -version = "0.0.6" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "ct3" }, - { name = "numpy" }, - { name = "setuptools" }, - { name = "typing-extensions" }, - { name = "witty" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/eb/d9/0b1014a2d8c280801e86a1b61716f5987edd78c5bee1c914e35ae51dd0dc/spatial_graph-0.0.6.tar.gz", hash = "sha256:5e605ebc6940040db6405f259c729d2bf76f9bec9c3d0a081ef111e9c33cc812", size = 51898, upload-time = "2026-06-09T16:58:47.514Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/3c/f5/f765c87da4a63ac6fc61364cf32cf07bbf4b5b27501ee4e50b5e54d0fcd9/spatial_graph-0.0.6-py3-none-any.whl", hash = "sha256:dda770061facb7c900fd6fc77c9eb00c8ffa93aed70ca32c98f925029b688ffa", size = 48034, upload-time = "2026-06-09T16:58:46.471Z" }, -] - -[[package]] -name = "sphinx" -version = "9.1.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "alabaster" }, - { name = "babel" }, - { name = "colorama", marker = "sys_platform == 'win32'" }, - { name = "docutils" }, - { name = "imagesize" }, - { name = "jinja2" }, - { name = "packaging" }, - { name = "pygments" }, - { name = "requests" }, - { name = "roman-numerals" }, - { name = "snowballstemmer" }, - { name = "sphinxcontrib-applehelp" }, - { name = "sphinxcontrib-devhelp" }, - { name = "sphinxcontrib-htmlhelp" }, - { name = "sphinxcontrib-jsmath" }, - { name = "sphinxcontrib-qthelp" }, - { name = "sphinxcontrib-serializinghtml" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/cd/bd/f08eb0f4eed5c83f1ba2a3bd18f7745a2b1525fad70660a1c00224ec468a/sphinx-9.1.0.tar.gz", hash = "sha256:7741722357dd75f8190766926071fed3bdc211c74dd2d7d4df5404da95930ddb", size = 8718324, upload-time = "2025-12-31T15:09:27.646Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/73/f7/b1884cb3188ab181fc81fa00c266699dab600f927a964df02ec3d5d1916a/sphinx-9.1.0-py3-none-any.whl", hash = "sha256:c84fdd4e782504495fe4f2c0b3413d6c2bf388589bb352d439b2a3bb99991978", size = 3921742, upload-time = "2025-12-31T15:09:25.561Z" }, -] - -[[package]] -name = "sphinxcontrib-applehelp" -version = "2.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ba/6e/b837e84a1a704953c62ef8776d45c3e8d759876b4a84fe14eba2859106fe/sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1", size = 20053, upload-time = "2024-07-29T01:09:00.465Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", size = 119300, upload-time = "2024-07-29T01:08:58.99Z" }, -] - -[[package]] -name = "sphinxcontrib-devhelp" -version = "2.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f6/d2/5beee64d3e4e747f316bae86b55943f51e82bb86ecd325883ef65741e7da/sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad", size = 12967, upload-time = "2024-07-29T01:09:23.417Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", size = 82530, upload-time = "2024-07-29T01:09:21.945Z" }, -] - -[[package]] -name = "sphinxcontrib-htmlhelp" -version = "2.1.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/43/93/983afd9aa001e5201eab16b5a444ed5b9b0a7a010541e0ddfbbfd0b2470c/sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9", size = 22617, upload-time = "2024-07-29T01:09:37.889Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", size = 98705, upload-time = "2024-07-29T01:09:36.407Z" }, -] - -[[package]] -name = "sphinxcontrib-jsmath" -version = "1.0.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b2/e8/9ed3830aeed71f17c026a07a5097edcf44b692850ef215b161b8ad875729/sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8", size = 5787, upload-time = "2019-01-21T16:10:16.347Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", size = 5071, upload-time = "2019-01-21T16:10:14.333Z" }, -] - -[[package]] -name = "sphinxcontrib-qthelp" -version = "2.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/68/bc/9104308fc285eb3e0b31b67688235db556cd5b0ef31d96f30e45f2e51cae/sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab", size = 17165, upload-time = "2024-07-29T01:09:56.435Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", size = 88743, upload-time = "2024-07-29T01:09:54.885Z" }, -] - -[[package]] -name = "sphinxcontrib-serializinghtml" -version = "2.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/3b/44/6716b257b0aa6bfd51a1b31665d1c205fb12cb5ad56de752dfa15657de2f/sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d", size = 16080, upload-time = "2024-07-29T01:10:09.332Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072, upload-time = "2024-07-29T01:10:08.203Z" }, -] - [[package]] name = "sqlalchemy" version = "2.0.50" @@ -6032,6 +5923,20 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/05/f6/6809349130a2de0e109e7f00fd7d431da9565b9b2868b32ee684754f672b/sqlalchemy-2.0.50-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2b9dcc43afef8ac157cd92fce96985d6b8b0cfbd3df4d666f66b4d55a75d202f", size = 3269375, upload-time = "2026-05-24T20:17:20.34Z" }, { url = "https://files.pythonhosted.org/packages/48/84/278a811ef4e07be9c89dc5cdd7be833268509a66a68c4897cf585e67428f/sqlalchemy-2.0.50-cp313-cp313-win32.whl", hash = "sha256:60922d6599065ddca2c6f376b9aa2f41a6b85a271725e0909490bbc50b1998a5", size = 2117229, upload-time = "2026-05-24T19:50:08.215Z" }, { url = "https://files.pythonhosted.org/packages/f6/1c/067cc6187ed32d2ec222fe6d2643acc1659a6d0659f8a7cbc5ad3ae83280/sqlalchemy-2.0.50-cp313-cp313-win_amd64.whl", hash = "sha256:287086e67275a212c4582d166a6fb03a65ccc5551d80866270ce0dd9f34eccd3", size = 2143126, upload-time = "2026-05-24T19:50:09.691Z" }, + { url = "https://files.pythonhosted.org/packages/df/32/10ac51b4be7cdecd7e93d069251c86dfbf70b7adbd7c67b48ccea6c49e1c/sqlalchemy-2.0.50-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c966932507a4d7d0a37314927dbfcd89720e3f37d2a1e3352e7ae7939fa8e8a0", size = 2158519, upload-time = "2026-05-24T19:27:56.472Z" }, + { url = "https://files.pythonhosted.org/packages/5a/76/e703d2f7681d7d66c4c891af3f07c7ccf4c76ad7f18351de035b5eda007a/sqlalchemy-2.0.50-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:faffef4bcc20a1892e65e155293d99d60855bbbc79250ab712819cfd56a8e6bb", size = 3282063, upload-time = "2026-05-24T20:09:38.57Z" }, + { url = "https://files.pythonhosted.org/packages/31/26/ef168b184a25701f9995e8fb7e503fafd7a99c1c77cda1bc1a26ea2ed486/sqlalchemy-2.0.50-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c206aec519a2e7bd08abbfb33436e325fd22c632d9c21a9047e376ce241646e", size = 3287069, upload-time = "2026-05-24T20:17:21.942Z" }, + { url = "https://files.pythonhosted.org/packages/c2/15/765acc2bc693bccc43ca4a95d5b69750da8aaf6db1b5c616536e087f8920/sqlalchemy-2.0.50-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bef4ac756363227ef6402a75fee025a4bc690f92328e825868939b3b3a446a6d", size = 3230453, upload-time = "2026-05-24T20:09:40.398Z" }, + { url = "https://files.pythonhosted.org/packages/63/61/08e03c3adbf5db0087a0b6816746fec8f3032fb2f7fc899a9bb9b2a48ce4/sqlalchemy-2.0.50-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:96fbee6b19c19cd1556c8bf9419447cf2ec149ffcab7ab64348c23e54ef8547f", size = 3252413, upload-time = "2026-05-24T20:17:24.067Z" }, + { url = "https://files.pythonhosted.org/packages/03/0c/370a1f2db38436c615e10134c8a37de3688e74084792380695f3f5083860/sqlalchemy-2.0.50-cp314-cp314-win32.whl", hash = "sha256:8f00e3eb43ba30eb1b238ee03a8a62309486d1321eda3328bb611e0340033ad8", size = 2120063, upload-time = "2026-05-24T19:50:11.08Z" }, + { url = "https://files.pythonhosted.org/packages/7f/a0/fe92bb9817863bc13ba093bda931979a26cc2ca69f8e8f26d07add3d7c6f/sqlalchemy-2.0.50-cp314-cp314-win_amd64.whl", hash = "sha256:15708c613cd5005b7dffe1f66ee6a63ee8f5e46799f71c70ebad74178c676a39", size = 2145830, upload-time = "2026-05-24T19:50:12.452Z" }, + { url = "https://files.pythonhosted.org/packages/cc/ff/e5640a98a0b2f491eb8fde10fb6c773621a2e44340de231fafcc9370f4a9/sqlalchemy-2.0.50-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3699dac4be410e97049a1658e9480da9cde956594aa0f3aebc60b88f21c5ba70", size = 2178435, upload-time = "2026-05-24T19:42:58.889Z" }, + { url = "https://files.pythonhosted.org/packages/b7/85/337116e186f1236375b5fb70c21cfac98e8e8ab0d3a47be838dc47a59e08/sqlalchemy-2.0.50-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f96233858e3df43932ac11589e22520da6e8aeb624b03fedfeebb0e8ea213086", size = 3566059, upload-time = "2026-05-24T20:01:20.848Z" }, + { url = "https://files.pythonhosted.org/packages/96/34/bb0e190e161c3c2c24314a65add57218be14a4a9486886b7f5047c1ff7c8/sqlalchemy-2.0.50-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c4e70c46fad30c3bcc6a4708bc0130a3173e11a5b25f0ea4a9d8911b450f1f52", size = 3535366, upload-time = "2026-05-24T20:03:56.768Z" }, + { url = "https://files.pythonhosted.org/packages/df/5a/a7f759f97e4fd499c5d4e4488c760d5a7fbecf3028b465a04274fcd52384/sqlalchemy-2.0.50-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:1918a3cf564d16d95bca7301005f41ab2ad50b07cd3b9da50d3ed986db148d6a", size = 3474879, upload-time = "2026-05-24T20:01:23.058Z" }, + { url = "https://files.pythonhosted.org/packages/9d/d9/2907ea38eb60687d297bf9c39e5ee58053c87b57fe8a9cae97090cecbf10/sqlalchemy-2.0.50-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b00098cdbdbd38c7be3d568b0c9c3122b8c0ec62b911b57cd5e6e0254d60a76d", size = 3486117, upload-time = "2026-05-24T20:03:59.052Z" }, + { url = "https://files.pythonhosted.org/packages/f2/e3/5aa06f167559f8c0bdae487e297d23ba548150ab016a3418265d617a4985/sqlalchemy-2.0.50-cp314-cp314t-win32.whl", hash = "sha256:1fbd55a969d7ac44a98e3dec75016074f809fa08f871585ace58dde110d1bf3e", size = 2150823, upload-time = "2026-05-24T20:08:58.644Z" }, + { url = "https://files.pythonhosted.org/packages/65/9b/112fb8f977582d7489d036e409e3723948bcf5320b3ac465f3c481bbe8f9/sqlalchemy-2.0.50-cp314-cp314t-win_amd64.whl", hash = "sha256:c5c3cdb753a9004183e1ccb634b41611654c989e61bc68617ce878e46d6f1e51", size = 2185794, upload-time = "2026-05-24T20:09:00.319Z" }, { url = "https://files.pythonhosted.org/packages/d0/10/f7220e9b784d295d241c86ed99aeb537f92afcd469a64861f2717e9bb077/sqlalchemy-2.0.50-py3-none-any.whl", hash = "sha256:92064363517a3ff8212b5a93b8c62876579d8dfd1ca5b561335f30152d884fa9", size = 1943861, upload-time = "2026-05-24T19:59:01.119Z" }, ] @@ -6049,19 +5954,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" }, ] -[[package]] -name = "starlette" -version = "1.3.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "anyio" }, - { name = "typing-extensions", marker = "python_full_version < '3.13'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/eb/e3/7c1dc7381d9f8ab7d854328ebfa884e62cb3f3d8549ddfd37c7814f42afa/starlette-1.3.1.tar.gz", hash = "sha256:05d0213193f2fbaae60e2ecb593b4add4262ad4e46536b54abe36f11a71724e0", size = 2703240, upload-time = "2026-06-12T09:23:11.602Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ec/bb/2799cc2ede3ed41131f8975621e7213dfc7ef4acbbaadfa440f32500c370/starlette-1.3.1-py3-none-any.whl", hash = "sha256:c7372aae11c3c3f26a42df7bd626cec2f47d03483d261d369516a615a53714c6", size = 73632, upload-time = "2026-06-12T09:23:10.017Z" }, -] - [[package]] name = "statsmodels" version = "0.14.6" @@ -6087,25 +5979,12 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/10/b9/fd41f1f6af13a1a1212a06bb377b17762feaa6d656947bf666f76300fc05/statsmodels-0.14.6-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:730f3297b26749b216a06e4327fe0be59b8d05f7d594fb6caff4287b69654589", size = 10324155, upload-time = "2025-12-05T23:12:01.805Z" }, { url = "https://files.pythonhosted.org/packages/ee/0f/a6900e220abd2c69cd0a07e3ad26c71984be6061415a60e0f17b152ecf08/statsmodels-0.14.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f1c08befa85e93acc992b72a390ddb7bd876190f1360e61d10cf43833463bc9c", size = 10349765, upload-time = "2025-12-05T23:12:18.018Z" }, { url = "https://files.pythonhosted.org/packages/98/08/b79f0c614f38e566eebbdcff90c0bcacf3c6ba7a5bbb12183c09c29ca400/statsmodels-0.14.6-cp313-cp313-win_amd64.whl", hash = "sha256:8021271a79f35b842c02a1794465a651a9d06ec2080f76ebc3b7adce77d08233", size = 9540043, upload-time = "2025-12-05T23:12:33.887Z" }, -] - -[[package]] -name = "superqt" -version = "0.8.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pygments" }, - { name = "qtpy" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/84/fe/919245507b15b4633cd40292d69c3b6afa8a650bf3ec33f3329d26314a3c/superqt-0.8.2.tar.gz", hash = "sha256:faa3bd00ef1c9b209b1f31b154dd41c596fec3824f61a70c251fb5569acd7ba6", size = 110190, upload-time = "2026-05-18T14:33:47.027Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/01/b9/748c3cbcdba20ef01c055a35905cad5c771cc1df29be11b9a82da6fd8e0d/superqt-0.8.2-py3-none-any.whl", hash = "sha256:ce8400ae7b577d090368aae5bdbabb06cd6bc893f6ca73485bb686835bf20943", size = 101595, upload-time = "2026-05-18T14:33:45.462Z" }, -] - -[package.optional-dependencies] -iconify = [ - { name = "pyconify" }, + { url = "https://files.pythonhosted.org/packages/71/de/09540e870318e0c7b58316561d417be45eff731263b4234fdd2eee3511a8/statsmodels-0.14.6-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:00781869991f8f02ad3610da6627fd26ebe262210287beb59761982a8fa88cae", size = 10069403, upload-time = "2025-12-05T23:12:48.424Z" }, + { url = "https://files.pythonhosted.org/packages/ab/f0/63c1bfda75dc53cee858006e1f46bd6d6f883853bea1b97949d0087766ca/statsmodels-0.14.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:73f305fbf31607b35ce919fae636ab8b80d175328ed38fdc6f354e813b86ee37", size = 9989253, upload-time = "2025-12-05T23:13:05.274Z" }, + { url = "https://files.pythonhosted.org/packages/c1/98/b0dfb4f542b2033a3341aa5f1bdd97024230a4ad3670c5b0839d54e3dcab/statsmodels-0.14.6-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e443e7077a6e2d3faeea72f5a92c9f12c63722686eb80bb40a0f04e4a7e267ad", size = 10090802, upload-time = "2025-12-05T23:13:20.653Z" }, + { url = "https://files.pythonhosted.org/packages/34/0e/2408735aca9e764643196212f9069912100151414dd617d39ffc72d77eee/statsmodels-0.14.6-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3414e40c073d725007a6603a18247ab7af3467e1af4a5e5a24e4c27bc26673b4", size = 10337587, upload-time = "2025-12-05T23:13:37.597Z" }, + { url = "https://files.pythonhosted.org/packages/0f/36/4d44f7035ab3c0b2b6a4c4ebb98dedf36246ccbc1b3e2f51ebcd7ac83abb/statsmodels-0.14.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a518d3f9889ef920116f9fa56d0338069e110f823926356946dae83bc9e33e19", size = 10363350, upload-time = "2025-12-05T23:13:53.08Z" }, + { url = "https://files.pythonhosted.org/packages/26/33/f1652d0c59fa51de18492ee2345b65372550501ad061daa38f950be390b6/statsmodels-0.14.6-cp314-cp314-win_amd64.whl", hash = "sha256:151b73e29f01fe619dbce7f66d61a356e9d1fe5e906529b78807df9189c37721", size = 9588010, upload-time = "2025-12-05T23:14:07.28Z" }, ] [[package]] @@ -6206,6 +6085,14 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/6d/b6/d574e2b758631563861d51cba4cc595d27a3965db3473a05ab268eead05b/tensordict-0.12.4-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:6e60888bc24990ead02d52f16fa607af8c01c92089ad767540eca88ade5fb49f", size = 535213, upload-time = "2026-05-22T00:09:39.561Z" }, { url = "https://files.pythonhosted.org/packages/13/a4/25c29e653878e58ed3cb111146e4dd8cdb4cfd4b6f66dd2080f94f8e78f4/tensordict-0.12.4-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:031c70d2101376e0fb8036b017c8271a27892c1b9ba6aea021c039c7535aac53", size = 539088, upload-time = "2026-05-22T00:09:41.377Z" }, { url = "https://files.pythonhosted.org/packages/35/6f/c8107ea679a60e7584bc6d36b854879a33f5a990819e174a7ed653edb781/tensordict-0.12.4-cp313-cp313t-win_amd64.whl", hash = "sha256:a1320ea2ed9e0289209b0efc51b8bf2bca02cf5273fade3aec4f60a4ddfed61b", size = 597644, upload-time = "2026-05-22T00:09:42.922Z" }, + { url = "https://files.pythonhosted.org/packages/7a/f7/ceeacc76ed53e3bc7ba428ee35fb42dad6fdcda4974d5685b89c89906ff5/tensordict-0.12.4-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:d52e2425ef8d509966819a8da240ed2681f685aa0ba61c155641d994587b398c", size = 890261, upload-time = "2026-05-22T00:09:44.823Z" }, + { url = "https://files.pythonhosted.org/packages/6b/f0/eec984a88be0a19c538556186dd6fa937d8d39d581348e40894246272fc8/tensordict-0.12.4-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:4b3bb6b1120c2c3759abc814d1cd5f38353a1488790d8e4fc1c11e7f0e36b4a9", size = 534472, upload-time = "2026-05-22T00:09:46.336Z" }, + { url = "https://files.pythonhosted.org/packages/a6/94/610a0fc9f62a573b24e21b2a2cf230cf896e2a7e54ddffbaddfd95e2d2d1/tensordict-0.12.4-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:ca594b8d67ffa899716c91922dcfcc9d7fa56ca332d43804076a6a7b54cce078", size = 537785, upload-time = "2026-05-22T00:09:47.932Z" }, + { url = "https://files.pythonhosted.org/packages/c6/4a/b49f6d1ef76d5b51ba45d7855b3845939006a823761fddf8ca6d9436e9a9/tensordict-0.12.4-cp314-cp314-win_amd64.whl", hash = "sha256:413a7d8f05e9c38fef564d73a754e878d3a771de9b46d5b62a12af7a9cde15e9", size = 587017, upload-time = "2026-05-22T00:09:49.452Z" }, + { url = "https://files.pythonhosted.org/packages/0f/58/e2bcdedf16e7693109d74ebdd642c45698e7aa79612f49e6d60e67c013c6/tensordict-0.12.4-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:9f0fa20d70b54afbdf8fba6da573e27c12637aad40c44262f9b864eee3c49188", size = 894689, upload-time = "2026-05-22T00:09:51.914Z" }, + { url = "https://files.pythonhosted.org/packages/b8/62/f04b168b747fd0b7feae2553b91c10cf85a833643a3d44973e775b098878/tensordict-0.12.4-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:e8a61b6396d57cb60cc6dca5e3e3879a3afa993adbcce438a0af75e22783bb84", size = 534805, upload-time = "2026-05-22T00:09:53.571Z" }, + { url = "https://files.pythonhosted.org/packages/92/73/f60905b7847fe915d667cde140afae0a853be4a928510ac7d702daaa4cb1/tensordict-0.12.4-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:fbe824052ba1d3fafe1ea53e27a3ac097a398bb1842aacdd27bf7e4715cc8df1", size = 538514, upload-time = "2026-05-22T00:09:55.313Z" }, + { url = "https://files.pythonhosted.org/packages/af/47/b814dc48e74a2c2335985652800809ef84579f7c827fc73583c308fdca56/tensordict-0.12.4-cp314-cp314t-win_amd64.whl", hash = "sha256:113c22d41b8d791cb1e3ec875c2a7e516cc271917de90d00b77d3102b029fc89", size = 597638, upload-time = "2026-05-22T00:09:56.843Z" }, ] [[package]] @@ -6228,6 +6115,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/4d/28/03e46405ba7c616e7a1ec5425a8f4a1b3f4d6ec2be359cb2f248199849e4/tensorstore-0.1.84-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:50afb06c57a509091015af6a85da6f483a7f5ad0372284dd95d5513d877336e4", size = 19344890, upload-time = "2026-05-16T06:17:28.956Z" }, { url = "https://files.pythonhosted.org/packages/5e/c6/82669e70cef67c803852285ba6f59d7e3d102983c0ab4be8269c14756677/tensorstore-0.1.84-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ea53a851ea86aad3d99c14a790c85468d6324be14c7ac211f1f0265e8fab707", size = 20968230, upload-time = "2026-05-16T06:17:31.374Z" }, { url = "https://files.pythonhosted.org/packages/a5/12/97d8ad183e3130e168f2feb860edd68f1b72e57f29268d980f3b70e34cd0/tensorstore-0.1.84-cp313-cp313-win_amd64.whl", hash = "sha256:fe9bf1c7fef69884a91222179550f9b5ba6c1454f9534429221824d9b15c00ec", size = 13398858, upload-time = "2026-05-16T06:17:33.658Z" }, + { url = "https://files.pythonhosted.org/packages/39/bd/fda828e7915ddb61704a6f4568b5b7ce9fe607c33b7535cf51b4fd900b38/tensorstore-0.1.84-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:97e767a64415297f019dd1e4b9af6a23d72e126e2a2d05cf41083253abe81428", size = 16576451, upload-time = "2026-05-16T06:17:35.993Z" }, + { url = "https://files.pythonhosted.org/packages/8a/99/2e72fcb19404de43f9412880c542a8ef8651bd30183c85454d6ca14ebe56/tensorstore-0.1.84-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d7d01775985fcaa2b0f100349766a953c5086e92e746bf395e936151d4d8f9ac", size = 14907896, upload-time = "2026-05-16T06:17:38.458Z" }, + { url = "https://files.pythonhosted.org/packages/25/d4/9a3964cdfdc5a15df6d0485694de9684c13990a5b0f5d88bfa365e0a2936/tensorstore-0.1.84-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b2ff5d5536a8a9b1596c51b9075cc9d40b4c4ea4e6cc03c0480111dbe5d956d", size = 19347021, upload-time = "2026-05-16T06:17:41.316Z" }, + { url = "https://files.pythonhosted.org/packages/43/19/70532cb2bf2f6fc3bf252f850bfb528b26eeb9c30c3cafffb075cbb7c77a/tensorstore-0.1.84-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c9108ae6c29adc90b72ca267ba2b577386c5e410ea2f8e87eabce5ebdad327e", size = 20970345, upload-time = "2026-05-16T06:17:43.874Z" }, + { url = "https://files.pythonhosted.org/packages/4e/22/a523e7576c83a6c35bd1415e5f4530b0f1e448c099d7e22684f55792755c/tensorstore-0.1.84-cp314-cp314-win_amd64.whl", hash = "sha256:4096220f4b9a2411c3751597dd8ced2f671d7a217575613c915191e19d5ea150", size = 13787429, upload-time = "2026-05-16T06:17:46.135Z" }, + { url = "https://files.pythonhosted.org/packages/2b/23/40b0a0a91973431770ac09a8b69039bd7a051169f6707b63a1c51ad36782/tensorstore-0.1.84-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:70284a7225d94adad5989de7f9238638ec9fec2bdd8c0fdb86d567f16d59e615", size = 16652804, upload-time = "2026-05-16T06:17:49.226Z" }, + { url = "https://files.pythonhosted.org/packages/01/99/2ea3b37864adb2e9f6e724c6959ab2b7f56aa4dad01964d4b32adf211e68/tensorstore-0.1.84-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:98e10cae5b3fc0828967b8ddf36242b3b26ac8bc79880bc3e36346063259212a", size = 14990904, upload-time = "2026-05-16T06:17:51.464Z" }, + { url = "https://files.pythonhosted.org/packages/ff/26/fe72887d7b91e832bef3033d244c4c548993d1b6fb19177dff3895659c12/tensorstore-0.1.84-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:98edbc57d453ba8ebcf0d19bc28e4de6de95922bee2eca0805955b0833b8ce26", size = 19365698, upload-time = "2026-05-16T06:17:53.748Z" }, + { url = "https://files.pythonhosted.org/packages/37/74/35a1d41343f86f6e2ef135e81f6b8107b9f16c777a3e8be9e3fbce541d18/tensorstore-0.1.84-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bd20de85c1b83dd3ca94db24e7bd449bdb055590a1b162b05691f6b81fff00f", size = 20986107, upload-time = "2026-05-16T06:17:56.571Z" }, ] [[package]] @@ -6319,15 +6215,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/72/f4/0de46cfa12cdcbcd464cc59fde36912af405696f687e53a091fb432f694c/tokenizers-0.22.2-cp39-abi3-win_arm64.whl", hash = "sha256:9ce725d22864a1e965217204946f830c37876eee3b2ba6fc6255e8e903d5fcbc", size = 2612133, upload-time = "2026-01-05T10:45:17.232Z" }, ] -[[package]] -name = "toml" -version = "0.10.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/be/ba/1f744cdc819428fc6b5084ec34d9b30660f6f9daaf70eead706e3203ec3c/toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f", size = 22253, upload-time = "2020-11-01T01:40:22.204Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b", size = 16588, upload-time = "2020-11-01T01:40:20.672Z" }, -] - [[package]] name = "tomli" version = "2.4.1" @@ -6352,18 +6239,27 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976, upload-time = "2026-03-25T20:21:39.316Z" }, { url = "https://files.pythonhosted.org/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755, upload-time = "2026-03-25T20:21:40.248Z" }, { url = "https://files.pythonhosted.org/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265, upload-time = "2026-03-25T20:21:41.219Z" }, + { url = "https://files.pythonhosted.org/packages/3c/fb/9a5c8d27dbab540869f7c1f8eb0abb3244189ce780ba9cd73f3770662072/tomli-2.4.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fd0409a3653af6c147209d267a0e4243f0ae46b011aa978b1080359fddc9b6cf", size = 155726, upload-time = "2026-03-25T20:21:42.23Z" }, + { url = "https://files.pythonhosted.org/packages/62/05/d2f816630cc771ad836af54f5001f47a6f611d2d39535364f148b6a92d6b/tomli-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a120733b01c45e9a0c34aeef92bf0cf1d56cfe81ed9d47d562f9ed591a9828ac", size = 149859, upload-time = "2026-03-25T20:21:43.386Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/66341bdb858ad9bd0ceab5a86f90eddab127cf8b046418009f2125630ecb/tomli-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:559db847dc486944896521f68d8190be1c9e719fced785720d2216fe7022b662", size = 244713, upload-time = "2026-03-25T20:21:44.474Z" }, + { url = "https://files.pythonhosted.org/packages/df/6d/c5fad00d82b3c7a3ab6189bd4b10e60466f22cfe8a08a9394185c8a8111c/tomli-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01f520d4f53ef97964a240a035ec2a869fe1a37dde002b57ebc4417a27ccd853", size = 252084, upload-time = "2026-03-25T20:21:45.62Z" }, + { url = "https://files.pythonhosted.org/packages/00/71/3a69e86f3eafe8c7a59d008d245888051005bd657760e96d5fbfb0b740c2/tomli-2.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7f94b27a62cfad8496c8d2513e1a222dd446f095fca8987fceef261225538a15", size = 247973, upload-time = "2026-03-25T20:21:46.937Z" }, + { url = "https://files.pythonhosted.org/packages/67/50/361e986652847fec4bd5e4a0208752fbe64689c603c7ae5ea7cb16b1c0ca/tomli-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ede3e6487c5ef5d28634ba3f31f989030ad6af71edfb0055cbbd14189ff240ba", size = 256223, upload-time = "2026-03-25T20:21:48.467Z" }, + { url = "https://files.pythonhosted.org/packages/8c/9a/b4173689a9203472e5467217e0154b00e260621caa227b6fa01feab16998/tomli-2.4.1-cp314-cp314-win32.whl", hash = "sha256:3d48a93ee1c9b79c04bb38772ee1b64dcf18ff43085896ea460ca8dec96f35f6", size = 98973, upload-time = "2026-03-25T20:21:49.526Z" }, + { url = "https://files.pythonhosted.org/packages/14/58/640ac93bf230cd27d002462c9af0d837779f8773bc03dee06b5835208214/tomli-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:88dceee75c2c63af144e456745e10101eb67361050196b0b6af5d717254dddf7", size = 109082, upload-time = "2026-03-25T20:21:50.506Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2f/702d5e05b227401c1068f0d386d79a589bb12bf64c3d2c72ce0631e3bc49/tomli-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:b8c198f8c1805dc42708689ed6864951fd2494f924149d3e4bce7710f8eb5232", size = 96490, upload-time = "2026-03-25T20:21:51.474Z" }, + { url = "https://files.pythonhosted.org/packages/45/4b/b877b05c8ba62927d9865dd980e34a755de541eb65fffba52b4cc495d4d2/tomli-2.4.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d4d8fe59808a54658fcc0160ecfb1b30f9089906c50b23bcb4c69eddc19ec2b4", size = 164263, upload-time = "2026-03-25T20:21:52.543Z" }, + { url = "https://files.pythonhosted.org/packages/24/79/6ab420d37a270b89f7195dec5448f79400d9e9c1826df982f3f8e97b24fd/tomli-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7008df2e7655c495dd12d2a4ad038ff878d4ca4b81fccaf82b714e07eae4402c", size = 160736, upload-time = "2026-03-25T20:21:53.674Z" }, + { url = "https://files.pythonhosted.org/packages/02/e0/3630057d8eb170310785723ed5adcdfb7d50cb7e6455f85ba8a3deed642b/tomli-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d8591993e228b0c930c4bb0db464bdad97b3289fb981255d6c9a41aedc84b2d", size = 270717, upload-time = "2026-03-25T20:21:55.129Z" }, + { url = "https://files.pythonhosted.org/packages/7a/b4/1613716072e544d1a7891f548d8f9ec6ce2faf42ca65acae01d76ea06bb0/tomli-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:734e20b57ba95624ecf1841e72b53f6e186355e216e5412de414e3c51e5e3c41", size = 278461, upload-time = "2026-03-25T20:21:56.228Z" }, + { url = "https://files.pythonhosted.org/packages/05/38/30f541baf6a3f6df77b3df16b01ba319221389e2da59427e221ef417ac0c/tomli-2.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a650c2dbafa08d42e51ba0b62740dae4ecb9338eefa093aa5c78ceb546fcd5c", size = 274855, upload-time = "2026-03-25T20:21:57.653Z" }, + { url = "https://files.pythonhosted.org/packages/77/a3/ec9dd4fd2c38e98de34223b995a3b34813e6bdadf86c75314c928350ed14/tomli-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:504aa796fe0569bb43171066009ead363de03675276d2d121ac1a4572397870f", size = 283144, upload-time = "2026-03-25T20:21:59.089Z" }, + { url = "https://files.pythonhosted.org/packages/ef/be/605a6261cac79fba2ec0c9827e986e00323a1945700969b8ee0b30d85453/tomli-2.4.1-cp314-cp314t-win32.whl", hash = "sha256:b1d22e6e9387bf4739fbe23bfa80e93f6b0373a7f1b96c6227c32bef95a4d7a8", size = 108683, upload-time = "2026-03-25T20:22:00.214Z" }, + { url = "https://files.pythonhosted.org/packages/12/64/da524626d3b9cc40c168a13da8335fe1c51be12c0a63685cc6db7308daae/tomli-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2c1c351919aca02858f740c6d33adea0c5deea37f9ecca1cc1ef9e884a619d26", size = 121196, upload-time = "2026-03-25T20:22:01.169Z" }, + { url = "https://files.pythonhosted.org/packages/5a/cd/e80b62269fc78fc36c9af5a6b89c835baa8af28ff5ad28c7028d60860320/tomli-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:eab21f45c7f66c13f2a9e0e1535309cee140182a9cdae1e041d02e47291e8396", size = 100393, upload-time = "2026-03-25T20:22:02.137Z" }, { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" }, ] -[[package]] -name = "tomli-w" -version = "1.2.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/19/75/241269d1da26b624c0d5e110e8149093c759b7a286138f4efd61a60e75fe/tomli_w-1.2.0.tar.gz", hash = "sha256:2dd14fac5a47c27be9cd4c976af5a12d87fb1f0b4512f81d69cce3b35ae25021", size = 7184, upload-time = "2025-01-15T12:07:24.262Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c7/18/c86eb8e0202e32dd3df50d43d7ff9854f8e0603945ff398974c1d91ac1ef/tomli_w-1.2.0-py3-none-any.whl", hash = "sha256:188306098d013b691fcadc011abd66727d3c414c571bb01b1a174ba8c983cf90", size = 6675, upload-time = "2025-01-15T12:07:22.074Z" }, -] - [[package]] name = "toolz" version = "1.1.0" @@ -6407,6 +6303,14 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b7/07/055d06d985b445d67422d25b033c11cf55bbb81785d4c4e68e28bca5820e/torch-2.12.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:af68dbf403439cae9ceaeaaf92f8352b460787dcd27b92aa05c40dd4a19c0f1e", size = 426397656, upload-time = "2026-05-13T14:52:38.84Z" }, { url = "https://files.pythonhosted.org/packages/43/94/b0b4fdc3014122e0a7302fb90086d352aa48f2576f0b252561ebb38c01a8/torch-2.12.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:a6a2eebb237d3b1d9ad3b378e86d9b9e0782afdea8b1e0eba6a13646b9b49c07", size = 532183124, upload-time = "2026-05-13T14:53:16.178Z" }, { url = "https://files.pythonhosted.org/packages/d8/c8/052405e6ad05d3237bfe5a4df78f917773956f8e17813a2d44c059068b74/torch-2.12.0-cp313-cp313t-win_amd64.whl", hash = "sha256:2140e373e9a51a3e22ef62e8d14366d0b470d18f0adf19fdc757368077133a34", size = 123232462, upload-time = "2026-05-13T14:52:27.26Z" }, + { url = "https://files.pythonhosted.org/packages/67/dc/ac069f8d6e8be701535921141055293b0d4819d3d7f224a4612cf157c7f9/torch-2.12.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:f7dfae4a519197dfa050e98d8e36378a0fb5899625a875c2b54445005a2e404e", size = 88027282, upload-time = "2026-05-13T14:53:05.258Z" }, + { url = "https://files.pythonhosted.org/packages/33/c3/1c1eb00e34555b536dddf792676026a988d710ed36981aa00499b36b0620/torch-2.12.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:891c769072637c74e9a5a77a3bc782894696d8ffec83b938df8536dee7f0ba78", size = 426386961, upload-time = "2026-05-13T14:51:28.406Z" }, + { url = "https://files.pythonhosted.org/packages/cd/d4/7e730dba0c7032a4154dc9056b76cf9625515e030e269cfbf8098fcfee7d/torch-2.12.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:e2ad3eb85d39c3cab62dfa93ed5a73516e6a53c6713cb97d004004fe089f0f1f", size = 532272265, upload-time = "2026-05-13T14:51:59.308Z" }, + { url = "https://files.pythonhosted.org/packages/f1/b4/92c80d1bbfee1c0036c06d1d2155a3065bd2423134c83bf8a47e65cd6b9b/torch-2.12.0-cp314-cp314-win_amd64.whl", hash = "sha256:c66696857e987efb8bc1777a37357ec4f60ab5e8af6250b83d6034437fa2d8f3", size = 122987138, upload-time = "2026-05-13T14:51:45.942Z" }, + { url = "https://files.pythonhosted.org/packages/7b/78/2e12b37ce50a19a037d7bc62d652a5a8f27385a7b05859d6bc9204f20cfe/torch-2.12.0-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:b4556715c8572758625d62b6e0ae3b1f76c440221913a6fb5e100f321fb4fb02", size = 88320100, upload-time = "2026-05-13T14:51:39.955Z" }, + { url = "https://files.pythonhosted.org/packages/56/5e/83c450ec7b0bb40a7b74611c1b5440f9260e33c54c90d556fd4a1f0fd955/torch-2.12.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:a43ac605a5e13116c72b64c359644cce0229f213dde48d2ae0ae5eb5becf7feb", size = 426391871, upload-time = "2026-05-13T14:52:14.989Z" }, + { url = "https://files.pythonhosted.org/packages/c9/e9/1a0b575d98d0afedd8f157d23fa3d2759421483660448e60d0a4b10b6daa/torch-2.12.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:6a7512adfdd7f6732e40de1c620831e3c75b39b98cef60b11d0c5f0a76473ec5", size = 532192241, upload-time = "2026-05-13T14:51:07.795Z" }, + { url = "https://files.pythonhosted.org/packages/88/21/afadd25ecd81b3cea1e11c73cf1ab41a983a50271548c3ec7ec3b9efc3e9/torch-2.12.0-cp314-cp314t-win_amd64.whl", hash = "sha256:5f96b63f8287f66a005dd1b5a6abba2920f11156c5e5c4d815f3e2050fd1aa16", size = 123231092, upload-time = "2026-05-13T14:51:18.854Z" }, ] [[package]] @@ -6471,6 +6375,14 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/23/b9/9dbdf76b2b49a75ba8088df6f7c755bdb520afb6c6dbac0102b46cde5e99/torchvision-0.27.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:1c01f0d1091ae22b9dfc082b0a0fe5faaf053686a29b4fb082ba7691375c73cf", size = 7791430, upload-time = "2026-05-13T14:56:56.206Z" }, { url = "https://files.pythonhosted.org/packages/5c/6a/e4a16cf2f3310c2ea7760dc5d9054496844391e0f4c1fae87fefac2f3d9e/torchvision-0.27.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:dadea3c5ecfd05bbb2a3312ab0374f213c58bf6459cb059122e2f4dfe13d10ed", size = 7668441, upload-time = "2026-05-13T14:57:02.127Z" }, { url = "https://files.pythonhosted.org/packages/00/70/01b6461117a6a94b5af3f8ee166bb0f045056f3cf187750c110dabfdfffa/torchvision-0.27.0-cp313-cp313t-win_amd64.whl", hash = "sha256:a49e55055a39a8506fe7e59850522cab004efb2c3839f6057658889c1d69c815", size = 4141602, upload-time = "2026-05-13T14:56:53.449Z" }, + { url = "https://files.pythonhosted.org/packages/92/22/c0633677b3b3f3e69554a21ac087bf705f829c40cd5e3783507b8c006681/torchvision-0.27.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:c1fac0fc2a7adf29481fc1938a0e7845c57ba1147a986784109c4d98f434ea8c", size = 1758818, upload-time = "2026-05-13T14:56:54.988Z" }, + { url = "https://files.pythonhosted.org/packages/48/e8/55f9d9667b56dae470e69e31beac9b00d458ea393feec1aae95cc4f3f1c9/torchvision-0.27.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:cbf89764fc76f3f17fbf80c12d5a89c691e91cb9d82c38412aaf0568655ffb19", size = 7789667, upload-time = "2026-05-13T14:56:48.858Z" }, + { url = "https://files.pythonhosted.org/packages/00/bc/6f8681daf3bbc4c315bb0005110f99d28e3ecd675bf9c8f2c0d393fbac7a/torchvision-0.27.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:91f61b9865423037c327eb56afa207cc72de874e458c361840db9dcf5ce0c0eb", size = 7579848, upload-time = "2026-05-13T14:56:38.209Z" }, + { url = "https://files.pythonhosted.org/packages/19/6c/8d8020e6bd1e46c53e487c9c4e9457a07f2ee28931028fb5d71e2da40adc/torchvision-0.27.0-cp314-cp314-win_amd64.whl", hash = "sha256:5bb82fc3c55daf1788621e504310b0a286f1069627a8742f692aebb075ef25a7", size = 4119284, upload-time = "2026-05-13T14:56:46.625Z" }, + { url = "https://files.pythonhosted.org/packages/8d/7e/e78c48662a8d551606efdbe11c6b9c1d6d2391b92cd0e4591b9e6a2412b8/torchvision-0.27.0-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:2c4099a15150143b9b034730b404a56d572efe0b79489b4c765d929cb4eac7f3", size = 1758828, upload-time = "2026-05-13T14:56:52.293Z" }, + { url = "https://files.pythonhosted.org/packages/21/dd/d03ee9f9ee7bf11a8c7c776fb8e7fd6102f59c013791a2a4e5175bd6cba7/torchvision-0.27.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:b4c6bb0a670dcba017b3643e21902c9b8a1cc1c127d602f1488fa29ec3c6e865", size = 7790618, upload-time = "2026-05-13T14:56:44.721Z" }, + { url = "https://files.pythonhosted.org/packages/39/08/4002336a74742be70728603ec1769feb2b55e0d19c532c9ec9f92008de76/torchvision-0.27.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:1c2db4bde82bc48ebff73436a6adf34d4f809448268a70d9a1285f5c8f92313d", size = 7580217, upload-time = "2026-05-13T14:56:43.274Z" }, + { url = "https://files.pythonhosted.org/packages/ed/cb/4dd4783eb3565f526ba6e64b6f6ca26c00eacc924cdfe60455db9d91b84b/torchvision-0.27.0-cp314-cp314t-win_amd64.whl", hash = "sha256:72bf547e58ddb948689734eed6f4b6a2031f979dba4fb08e3690688b392e929f", size = 4226392, upload-time = "2026-05-13T14:56:40.235Z" }, ] [[package]] @@ -6504,8 +6416,8 @@ wheels = [ [[package]] name = "tracksdata" -version = "0.1.0rc3.dev3+gb605d2d6a" -source = { git = "https://github.com/royerlab/tracksdata?rev=b605d2d6aa4bd12a31c07b499f5acf8411bac518#b605d2d6aa4bd12a31c07b499f5acf8411bac518" } +version = "0.1.0rc4" +source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "bidict" }, { name = "blosc2" }, @@ -6524,6 +6436,11 @@ dependencies = [ { name = "sqlalchemy" }, { name = "tqdm" }, { name = "typing-extensions" }, + { name = "zarr" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/16/54/87f53a7cb255d1d76e6340b4799a84cfcedcf83aaa76926836236a7af3f8/tracksdata-0.1.0rc4.tar.gz", hash = "sha256:7f1f66293369ab1cf9de1884ba302682e494babca138d21d04e90cc7ae4538bc", size = 223977, upload-time = "2026-05-29T00:36:47.365Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/19/c2f4e1f8f347b4d8fb1266d65461d012a8b2b0baddec23814749ee01df8a/tracksdata-0.1.0rc4-py3-none-any.whl", hash = "sha256:0db3477549b8324647aa86d0a76983ae4aee9e6a8943fbb4187169c66e08e6dc", size = 253578, upload-time = "2026-05-29T00:36:45.876Z" }, ] [[package]] @@ -6566,6 +6483,10 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/30/b1/b7507bb9815d403927c8dd51d4158ed2e11751a92dbc118a044f247b6848/triton-3.7.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a35d7afe3f3f058e7ec49fcce09794049e0ffc5c59019ac25ec3413741b8c4e7", size = 201453566, upload-time = "2026-05-07T18:46:20.427Z" }, { url = "https://files.pythonhosted.org/packages/a6/8f/0bea7a6a0c989315c9135a1d7fb37e41905cfb3a17cbc1f10044ebd4cc3a/triton-3.7.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cc1d61c172d257db80ddf42595131fb196ad2e9bdd751e90fe2ef13531734e8b", size = 188612899, upload-time = "2026-05-07T19:05:24.955Z" }, { url = "https://files.pythonhosted.org/packages/e1/02/d96f57828d0912aec733b9bc7e0e7dbfd2c6f079a8fa433ac25cb93d1a30/triton-3.7.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70fb9bbdc9f400afc54bbf6eb2670af28829a6ae3996863317964783141daf56", size = 201553816, upload-time = "2026-05-07T18:46:27.49Z" }, + { url = "https://files.pythonhosted.org/packages/40/fb/82a802dac4689f2a2fb2e69302e6a138eecc3e175bbe976ba3cfc717683a/triton-3.7.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a44a8476d0d3571eac4e4d1048e1ff75aad81a09ff4602ccfc56c6dea1672e", size = 188507879, upload-time = "2026-05-07T19:05:32.209Z" }, + { url = "https://files.pythonhosted.org/packages/8f/af/9904ec6d3c93d9b24e5ec360445bbdf758b7f00bfbeedb89cb0eb64eb8bb/triton-3.7.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b9b85e72968a9d8bba5ddb24e9b64aaabaf48affb042f2755cb7cfa92b7531ce", size = 201460637, upload-time = "2026-05-07T18:46:34.749Z" }, + { url = "https://files.pythonhosted.org/packages/a1/f9/4835a8ea746b88727d8899f4e3ccce4f9cacb38abfc3bb0a638266c53111/triton-3.7.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:18a160de426fd99f92b0baf509045360afbd3bfaa0b4a5171dde800ec9f09684", size = 188608706, upload-time = "2026-05-07T19:05:39.218Z" }, + { url = "https://files.pythonhosted.org/packages/c1/68/fa86e5a39608000f645535b2c124920126327ab731f8c4fafd5b07ff8d4b/triton-3.7.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ce061073102714b725f3660ec6939d94a1da7984b3aa99c921417cae273672f5", size = 201546766, upload-time = "2026-05-07T18:46:42.088Z" }, ] [[package]] @@ -6626,131 +6547,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", hash = "sha256:bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7", size = 349321, upload-time = "2026-04-24T15:22:05.876Z" }, ] -[[package]] -name = "ultrack" -source = { editable = "../../../../../home/eduardo.hirata/repos/ultrack" } -dependencies = [ - { name = "blosc2" }, - { name = "click" }, - { name = "cloudpickle" }, - { name = "edt" }, - { name = "fastapi" }, - { name = "fasteners" }, - { name = "geff" }, - { name = "gurobipy" }, - { name = "higra" }, - { name = "httpx" }, - { name = "imagecodecs" }, - { name = "imageio" }, - { name = "magicgui" }, - { name = "mip" }, - { name = "napari" }, - { name = "numba" }, - { name = "numcodecs" }, - { name = "ome-zarr" }, - { name = "pandas" }, - { name = "pillow" }, - { name = "psycopg2-binary" }, - { name = "psygnal" }, - { name = "pyarrow" }, - { name = "pydantic" }, - { name = "pydantic-settings" }, - { name = "pydot" }, - { name = "qtawesome" }, - { name = "qtpy" }, - { name = "rich" }, - { name = "scikit-image" }, - { name = "seaborn" }, - { name = "sqlalchemy" }, - { name = "toml" }, - { name = "torch" }, - { name = "urllib3" }, - { name = "uvicorn" }, - { name = "websockets" }, - { name = "zarr" }, -] - -[package.metadata] -requires-dist = [ - { name = "asv", marker = "extra == 'test'", specifier = ">=0.5.1" }, - { name = "autodoc-pydantic", marker = "extra == 'docs'" }, - { name = "blosc2", specifier = ">=2.2.0" }, - { name = "catboost", marker = "extra == 'ml'", specifier = ">=1.2.7" }, - { name = "click", specifier = ">=8.1.3" }, - { name = "cloudpickle", specifier = ">=3.0.0" }, - { name = "edt", specifier = ">=2.3.2" }, - { name = "fastapi", specifier = ">=0.109.2" }, - { name = "fasteners", specifier = ">=0.20" }, - { name = "furo", marker = "extra == 'docs'" }, - { name = "geff", specifier = ">=1.0.0" }, - { name = "gurobipy", specifier = ">=9.0.0,!=12.0.0" }, - { name = "higra", specifier = ">=0.6.10" }, - { name = "httpx", specifier = ">=0.26.0" }, - { name = "imagecodecs", specifier = ">=2023.3.16" }, - { name = "imageio", specifier = ">=2.28.0" }, - { name = "magicgui", specifier = ">=0.7.2" }, - { name = "mip", specifier = ">=1.16rc0" }, - { name = "myst-parser", marker = "extra == 'docs'", specifier = ">=2.0.0" }, - { name = "napari", specifier = ">=0.4.18" }, - { name = "napari", extras = ["testing"], marker = "extra == 'test'", specifier = ">0.4.18" }, - { name = "nbsphinx", marker = "extra == 'docs'", specifier = ">=0.9.3" }, - { name = "numba", specifier = ">=0.57.0" }, - { name = "numcodecs" }, - { name = "ome-zarr", specifier = ">=0.9.0" }, - { name = "pandas", specifier = ">=2.0.1" }, - { name = "pillow", specifier = ">=10.0.0" }, - { name = "pre-commit", marker = "extra == 'test'", specifier = ">=3.2.2" }, - { name = "psycopg2-binary", specifier = ">=2.9.6" }, - { name = "psygnal", specifier = ">=0.9.0" }, - { name = "pyarrow", specifier = ">=16.1.0,<20" }, - { name = "pydantic", specifier = ">=2.11.0" }, - { name = "pydantic-settings" }, - { name = "pydot", specifier = ">=2.0.0" }, - { name = "pyqt5", marker = "extra == 'test'", specifier = ">=5.15.4" }, - { name = "pytest", marker = "extra == 'test'", specifier = ">=7.3.1" }, - { name = "pytest-qt", marker = "extra == 'test'", specifier = ">=4.2.0" }, - { name = "pytrackmate", marker = "extra == 'test'", specifier = ">=1.3.4" }, - { name = "qtawesome", specifier = ">=1.3.1" }, - { name = "qtpy" }, - { name = "rich", specifier = ">=13.3.5" }, - { name = "scikit-image", specifier = ">=0.23.0" }, - { name = "scikit-learn", marker = "extra == 'ml'", specifier = ">=1.6.0" }, - { name = "seaborn", specifier = ">=0.13.0" }, - { name = "sphinx", marker = "extra == 'docs'", specifier = "==6.2.1" }, - { name = "sphinx-click", marker = "extra == 'docs'", specifier = ">=5.0.1,<6.0.0" }, - { name = "sphinx-copybutton", marker = "extra == 'docs'" }, - { name = "sphinx-gallery", marker = "extra == 'docs'", specifier = "==0.15.0" }, - { name = "sphinxcontrib-applehelp", marker = "extra == 'docs'", specifier = "==1.0.8" }, - { name = "sqlalchemy", specifier = ">=2.0.0" }, - { name = "toml", specifier = ">=0.10.2" }, - { name = "torch", specifier = ">=2.0.1" }, - { name = "urllib3" }, - { name = "uvicorn", specifier = ">=0.27.0.post1" }, - { name = "websockets", specifier = ">=12.0" }, - { name = "zarr", specifier = ">=3.0.0" }, -] -provides-extras = ["docs", "ml", "test"] - -[[package]] -name = "ultrack-td" -version = "0.0.1" -source = { editable = "../../../../../home/eduardo.hirata/repos/ultrack-td" } -dependencies = [ - { name = "numpy" }, - { name = "tracksdata" }, -] - -[package.metadata] -requires-dist = [ - { name = "edt", marker = "extra == 'test'" }, - { name = "numpy", specifier = ">=1.24.4" }, - { name = "pytest", marker = "extra == 'test'" }, - { name = "rustworkx", marker = "extra == 'test'" }, - { name = "tracksdata", specifier = ">=0.1.0rc0" }, - { name = "ultrack", marker = "extra == 'compatibility'" }, -] -provides-extras = ["compatibility", "test"] - [[package]] name = "umap-learn" version = "0.5.12" @@ -6786,19 +6582,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" }, ] -[[package]] -name = "uvicorn" -version = "0.49.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "click" }, - { name = "h11" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/c4/1f/fa18009dea8469069cca78a4e877a008ab78f08b064bfc9ab891579077ff/uvicorn-0.49.0.tar.gz", hash = "sha256:ebf4271aa580d9de97f93192d4595176df6e91f9aae919ca73e4fc07df1e66a3", size = 91284, upload-time = "2026-06-03T22:01:30.448Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/88/fa/e1388bbcf24ef3274f45c0c1c7b501fd14971037c1b6ee23610553307497/uvicorn-0.49.0-py3-none-any.whl", hash = "sha256:ba3d14c3ee7e41c6c654c46c9eb489d33213cdd30aa1696eab1374337c13f68f", size = 71376, upload-time = "2026-06-03T22:01:29.037Z" }, -] - [[package]] name = "verspec" version = "0.1.0" @@ -6824,6 +6607,7 @@ dev = [ { name = "jupyterlab" }, { name = "pytest" }, { name = "pytest-cov" }, + { name = "pytest-xdist" }, ] doc = [ { name = "mike" }, @@ -6837,6 +6621,7 @@ jupyter = [ test = [ { name = "pytest" }, { name = "pytest-cov" }, + { name = "pytest-xdist" }, ] [package.metadata] @@ -6853,6 +6638,7 @@ dev = [ { name = "jupyterlab", specifier = ">=4.5.3" }, { name = "pytest", specifier = ">=9.0.2" }, { name = "pytest-cov", specifier = ">=7" }, + { name = "pytest-xdist", specifier = ">=3.8" }, ] doc = [ { name = "mike", git = "https://github.com/squidfunk/mike.git" }, @@ -6866,6 +6652,7 @@ jupyter = [ test = [ { name = "pytest", specifier = ">=9.0.2" }, { name = "pytest-cov", specifier = ">=7" }, + { name = "pytest-xdist", specifier = ">=3.8" }, ] [[package]] @@ -6974,6 +6761,7 @@ dependencies = [ [package.optional-dependencies] celldiff = [ { name = "diffusers" }, + { name = "scipy" }, { name = "torchdiffeq" }, ] @@ -6993,6 +6781,7 @@ requires-dist = [ { name = "monai", specifier = ">=1.5.2" }, { name = "numpy", specifier = ">=2.4.1" }, { name = "pytorch-metric-learning" }, + { name = "scipy", marker = "extra == 'celldiff'" }, { name = "timm", specifier = ">=1.0.15" }, { name = "torch", specifier = ">=2.10" }, { name = "torchdiffeq", marker = "extra == 'celldiff'" }, @@ -7201,7 +6990,7 @@ requires-dist = [ { name = "umap-learn", marker = "extra == 'all'" }, { name = "umap-learn", marker = "extra == 'eval'" }, { name = "viscy-data", editable = "packages/viscy-data" }, - { name = "wandb" }, + { name = "wandb", specifier = ">=0.12.10" }, { name = "xarray" }, ] provides-extras = ["all", "anndata", "eval"] @@ -7222,31 +7011,6 @@ test = [ { name = "scikit-learn" }, ] -[[package]] -name = "vispy" -version = "0.15.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "freetype-py" }, - { name = "hsluv" }, - { name = "kiwisolver" }, - { name = "numpy" }, - { name = "packaging" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/1b/2e/ef2697f963111cf1bc83568bbe55f262b7c7c8a72948a6e802a7c236f2c1/vispy-0.15.2.tar.gz", hash = "sha256:d52d10c0697f48990555cea2a2bad3f9f5a772391856fda364ea4bbc69fd075c", size = 2513383, upload-time = "2025-05-19T13:26:41.015Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/6f/7e/31102425ea26bafab27bb5a675b499c57d29e72b1cc25fe3ae8facdd374e/vispy-0.15.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c8cbc22bc789f238423abadfcc3ba7589b85729be6b179b321720b511012fbee", size = 1478919, upload-time = "2025-05-19T13:26:16.962Z" }, - { url = "https://files.pythonhosted.org/packages/8d/63/a601b8f1e8e418d3821d7b4a465c2eb6695ab8eccadfce886b99ffdfe92a/vispy-0.15.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bf995b86dcc1eab265fa2bf9a8a5ca5a225b86c3ed4ac63900f0c5e90d5e8100", size = 1471915, upload-time = "2025-05-19T13:26:18.441Z" }, - { url = "https://files.pythonhosted.org/packages/79/1f/ca0deb4a876148c0fa515bf03d03e1dfad4553be8e6f2ab51433c074310b/vispy-0.15.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0aa64fcab1cd1730a10a1c9188e9cef8aefe6d099a46f2f87e2458bcef719918", size = 1866848, upload-time = "2025-05-19T13:26:19.6Z" }, - { url = "https://files.pythonhosted.org/packages/ac/a4/dc6f335e54877f5d26ad4e4aac8f49b2d6e7719dee3e08f363d882c8aba4/vispy-0.15.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e9d38228cedd23876cb2359ff568d523a97284d225259d450d5e5e2129e98eb1", size = 1870433, upload-time = "2025-05-19T13:26:20.794Z" }, - { url = "https://files.pythonhosted.org/packages/a8/73/5ffa34d7300c35e8423d51789d594d35eaa7256d210f9909afa9fdd0aa37/vispy-0.15.2-cp312-cp312-win_amd64.whl", hash = "sha256:a84531c1a89f8b9d3992eb0d0ab74f84884f49d1f46a8be3755c809d7507cb01", size = 1468068, upload-time = "2025-05-19T13:26:22.073Z" }, - { url = "https://files.pythonhosted.org/packages/85/9a/6664b7f0d28e0008a28111bae847a1fa3eedd409458bf01ca45a6e99da6f/vispy-0.15.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2ac46aab46e208b919dcf0bb26869bcd083a0a1a4927bcaf41631ba38c247639", size = 1477880, upload-time = "2025-05-19T13:26:23.321Z" }, - { url = "https://files.pythonhosted.org/packages/cf/6f/b9b36f841c5ff7320764f64822e79df3fea8a2c92270cda7f3a634d9a031/vispy-0.15.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7e197a012503850a77d47177964d572edab964b2a8ea0f9d998c35b81325256c", size = 1471035, upload-time = "2025-05-19T13:26:24.554Z" }, - { url = "https://files.pythonhosted.org/packages/4c/af/b892a3c9b4be29755ce4d1fc17ecb8249446bdd0e17bb5b2a9cb39bcf0f4/vispy-0.15.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6d9eff397ecdbaf0052baae0563caa9e276272d6dc78fbaab3f5e51dbf5f7f92", size = 1860412, upload-time = "2025-05-19T13:26:26.212Z" }, - { url = "https://files.pythonhosted.org/packages/e8/13/8997d96bdc0a81f331dfd41b368935d79e8ea2917840266567e6dc40d684/vispy-0.15.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f13ee0cb95bbff6d7b235e1a8f96e620eee15ccb6d5ad74902427ab7e56dc8ab", size = 1865860, upload-time = "2025-05-19T13:26:27.928Z" }, - { url = "https://files.pythonhosted.org/packages/6e/37/abb30db1853b69aed4c32813cf312f301ec3641b8846193be9a6d892d607/vispy-0.15.2-cp313-cp313-win_amd64.whl", hash = "sha256:f5955821e9b452980490706648a702da8cb2b82e762b6d6589e5872118301b84", size = 1467882, upload-time = "2025-05-19T13:26:29.608Z" }, -] - [[package]] name = "wandb" version = "0.27.0" @@ -7360,33 +7124,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/34/db/b10e48aa8fff7407e67470363eac595018441cf32d5e1001567a7aeba5d2/websocket_client-1.9.0-py3-none-any.whl", hash = "sha256:af248a825037ef591efbf6ed20cc5faa03d3b47b9e5a2230a529eeee1c1fc3ef", size = 82616, upload-time = "2025-10-07T21:16:34.951Z" }, ] -[[package]] -name = "websockets" -version = "16.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/04/24/4b2031d72e840ce4c1ccb255f693b15c334757fc50023e4db9537080b8c4/websockets-16.0.tar.gz", hash = "sha256:5f6261a5e56e8d5c42a4497b364ea24d94d9563e8fbd44e78ac40879c60179b5", size = 179346, upload-time = "2026-01-10T09:23:47.181Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/84/7b/bac442e6b96c9d25092695578dda82403c77936104b5682307bd4deb1ad4/websockets-16.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:71c989cbf3254fbd5e84d3bff31e4da39c43f884e64f2551d14bb3c186230f00", size = 177365, upload-time = "2026-01-10T09:22:46.787Z" }, - { url = "https://files.pythonhosted.org/packages/b0/fe/136ccece61bd690d9c1f715baaeefd953bb2360134de73519d5df19d29ca/websockets-16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8b6e209ffee39ff1b6d0fa7bfef6de950c60dfb91b8fcead17da4ee539121a79", size = 175038, upload-time = "2026-01-10T09:22:47.999Z" }, - { url = "https://files.pythonhosted.org/packages/40/1e/9771421ac2286eaab95b8575b0cb701ae3663abf8b5e1f64f1fd90d0a673/websockets-16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86890e837d61574c92a97496d590968b23c2ef0aeb8a9bc9421d174cd378ae39", size = 175328, upload-time = "2026-01-10T09:22:49.809Z" }, - { url = "https://files.pythonhosted.org/packages/18/29/71729b4671f21e1eaa5d6573031ab810ad2936c8175f03f97f3ff164c802/websockets-16.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9b5aca38b67492ef518a8ab76851862488a478602229112c4b0d58d63a7a4d5c", size = 184915, upload-time = "2026-01-10T09:22:51.071Z" }, - { url = "https://files.pythonhosted.org/packages/97/bb/21c36b7dbbafc85d2d480cd65df02a1dc93bf76d97147605a8e27ff9409d/websockets-16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e0334872c0a37b606418ac52f6ab9cfd17317ac26365f7f65e203e2d0d0d359f", size = 186152, upload-time = "2026-01-10T09:22:52.224Z" }, - { url = "https://files.pythonhosted.org/packages/4a/34/9bf8df0c0cf88fa7bfe36678dc7b02970c9a7d5e065a3099292db87b1be2/websockets-16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a0b31e0b424cc6b5a04b8838bbaec1688834b2383256688cf47eb97412531da1", size = 185583, upload-time = "2026-01-10T09:22:53.443Z" }, - { url = "https://files.pythonhosted.org/packages/47/88/4dd516068e1a3d6ab3c7c183288404cd424a9a02d585efbac226cb61ff2d/websockets-16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:485c49116d0af10ac698623c513c1cc01c9446c058a4e61e3bf6c19dff7335a2", size = 184880, upload-time = "2026-01-10T09:22:55.033Z" }, - { url = "https://files.pythonhosted.org/packages/91/d6/7d4553ad4bf1c0421e1ebd4b18de5d9098383b5caa1d937b63df8d04b565/websockets-16.0-cp312-cp312-win32.whl", hash = "sha256:eaded469f5e5b7294e2bdca0ab06becb6756ea86894a47806456089298813c89", size = 178261, upload-time = "2026-01-10T09:22:56.251Z" }, - { url = "https://files.pythonhosted.org/packages/c3/f0/f3a17365441ed1c27f850a80b2bc680a0fa9505d733fe152fdf5e98c1c0b/websockets-16.0-cp312-cp312-win_amd64.whl", hash = "sha256:5569417dc80977fc8c2d43a86f78e0a5a22fee17565d78621b6bb264a115d4ea", size = 178693, upload-time = "2026-01-10T09:22:57.478Z" }, - { url = "https://files.pythonhosted.org/packages/cc/9c/baa8456050d1c1b08dd0ec7346026668cbc6f145ab4e314d707bb845bf0d/websockets-16.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:878b336ac47938b474c8f982ac2f7266a540adc3fa4ad74ae96fea9823a02cc9", size = 177364, upload-time = "2026-01-10T09:22:59.333Z" }, - { url = "https://files.pythonhosted.org/packages/7e/0c/8811fc53e9bcff68fe7de2bcbe75116a8d959ac699a3200f4847a8925210/websockets-16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:52a0fec0e6c8d9a784c2c78276a48a2bdf099e4ccc2a4cad53b27718dbfd0230", size = 175039, upload-time = "2026-01-10T09:23:01.171Z" }, - { url = "https://files.pythonhosted.org/packages/aa/82/39a5f910cb99ec0b59e482971238c845af9220d3ab9fa76dd9162cda9d62/websockets-16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e6578ed5b6981005df1860a56e3617f14a6c307e6a71b4fff8c48fdc50f3ed2c", size = 175323, upload-time = "2026-01-10T09:23:02.341Z" }, - { url = "https://files.pythonhosted.org/packages/bd/28/0a25ee5342eb5d5f297d992a77e56892ecb65e7854c7898fb7d35e9b33bd/websockets-16.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:95724e638f0f9c350bb1c2b0a7ad0e83d9cc0c9259f3ea94e40d7b02a2179ae5", size = 184975, upload-time = "2026-01-10T09:23:03.756Z" }, - { url = "https://files.pythonhosted.org/packages/f9/66/27ea52741752f5107c2e41fda05e8395a682a1e11c4e592a809a90c6a506/websockets-16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0204dc62a89dc9d50d682412c10b3542d748260d743500a85c13cd1ee4bde82", size = 186203, upload-time = "2026-01-10T09:23:05.01Z" }, - { url = "https://files.pythonhosted.org/packages/37/e5/8e32857371406a757816a2b471939d51c463509be73fa538216ea52b792a/websockets-16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:52ac480f44d32970d66763115edea932f1c5b1312de36df06d6b219f6741eed8", size = 185653, upload-time = "2026-01-10T09:23:06.301Z" }, - { url = "https://files.pythonhosted.org/packages/9b/67/f926bac29882894669368dc73f4da900fcdf47955d0a0185d60103df5737/websockets-16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6e5a82b677f8f6f59e8dfc34ec06ca6b5b48bc4fcda346acd093694cc2c24d8f", size = 184920, upload-time = "2026-01-10T09:23:07.492Z" }, - { url = "https://files.pythonhosted.org/packages/3c/a1/3d6ccdcd125b0a42a311bcd15a7f705d688f73b2a22d8cf1c0875d35d34a/websockets-16.0-cp313-cp313-win32.whl", hash = "sha256:abf050a199613f64c886ea10f38b47770a65154dc37181bfaff70c160f45315a", size = 178255, upload-time = "2026-01-10T09:23:09.245Z" }, - { url = "https://files.pythonhosted.org/packages/6b/ae/90366304d7c2ce80f9b826096a9e9048b4bb760e44d3b873bb272cba696b/websockets-16.0-cp313-cp313-win_amd64.whl", hash = "sha256:3425ac5cf448801335d6fdc7ae1eb22072055417a96cc6b31b3861f455fbc156", size = 178689, upload-time = "2026-01-10T09:23:10.483Z" }, - { url = "https://files.pythonhosted.org/packages/6f/28/258ebab549c2bf3e64d2b0217b973467394a9cea8c42f70418ca2c5d0d2e/websockets-16.0-py3-none-any.whl", hash = "sha256:1637db62fad1dc833276dded54215f2c7fa46912301a24bd94d45d46a011ceec", size = 171598, upload-time = "2026-01-10T09:23:45.395Z" }, -] - [[package]] name = "werkzeug" version = "3.1.8" @@ -7414,20 +7151,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/3f/0e/fa3b193432cfc60c93b42f3be03365f5f909d2b3ea410295cf36df739e31/widgetsnbextension-4.0.15-py3-none-any.whl", hash = "sha256:8156704e4346a571d9ce73b84bee86a29906c9abfd7223b7228a28899ccf3366", size = 2196503, upload-time = "2025-11-01T21:15:53.565Z" }, ] -[[package]] -name = "witty" -version = "0.3.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "cython" }, - { name = "nanobind" }, - { name = "setuptools" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/79/55/8235436e9664dc824c07e9d50b4ff68088a7c3a53d4c971558616cb0fe63/witty-0.3.1.tar.gz", hash = "sha256:8ee71ba3321c77b64fd9d3a33c2f9ed2424cd7798ee22a4519687c2a88e0f108", size = 12198, upload-time = "2025-07-25T14:59:09.615Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e0/5e/82387eb68d7c9de328ae6ad0dbd12e3a6b71425f831f87e05738de509971/witty-0.3.1-py3-none-any.whl", hash = "sha256:e9bb379e06888a6857472f39e865e66ebb9b1523eb4725772f0b71f338e7dea6", size = 8845, upload-time = "2025-07-25T14:59:08.38Z" }, -] - [[package]] name = "wrapt" version = "2.2.1" @@ -7467,6 +7190,28 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/18/dc/b927ee9c7fc67adc3a5658f246a0d275425eb840ba36e7b702e70f18bde8/wrapt-2.2.1-cp313-cp313t-win32.whl", hash = "sha256:9907a4402ab6db12b7077a0ea5d7a4d028ecb22c8eee2b53527080d347cd1562", size = 79448, upload-time = "2026-05-22T14:48:47.901Z" }, { url = "https://files.pythonhosted.org/packages/ec/b3/fd30b473fe498c70e6b9a5f328b8d3fbaf1b8c3c481465f59724bba8eb70/wrapt-2.2.1-cp313-cp313t-win_amd64.whl", hash = "sha256:5590d63f5243251641cf543009b4c9314a79d0598fdb8a8e4cfc918494536c53", size = 83021, upload-time = "2026-05-22T14:48:49.201Z" }, { url = "https://files.pythonhosted.org/packages/ee/f3/96c39153a8737a6e9aa85adef254ac4195bea3f2d24efc60472ccc3c9e2e/wrapt-2.2.1-cp313-cp313t-win_arm64.whl", hash = "sha256:c318a64b53d97b841d7b5e637517e50a27be64bc695128422953d4b21710954e", size = 80295, upload-time = "2026-05-22T14:48:50.479Z" }, + { url = "https://files.pythonhosted.org/packages/0a/a3/11d7f34ebbf3231bc907a3e6d5ee051b14d034c1bc7b65a97d5cc00516df/wrapt-2.2.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:6f56a647e4eaf5f0ca40330fb070f566bdf9f7b0db89a1af20d71c28dcd7a0ab", size = 80879, upload-time = "2026-05-22T14:48:51.802Z" }, + { url = "https://files.pythonhosted.org/packages/13/3c/b74cfd984cef560b900fb1a727af20352d89e1f06bf2e1114dd3f00f5f5a/wrapt-2.2.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:64b7deeda4b70408e382328d8bbe52a256fe9bc63ae3db86d804608367e5422c", size = 81462, upload-time = "2026-05-22T14:48:53.18Z" }, + { url = "https://files.pythonhosted.org/packages/15/a3/7c8f704b8dc07dfe0a5d01c2edbfd88317aa8e5e3fa7c743eb7a085ae767/wrapt-2.2.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b9cf53ba90717db2e292401de290776c498d4bbfb0d4a559ca2895db8b9dcb5c", size = 167251, upload-time = "2026-05-22T14:48:54.562Z" }, + { url = "https://files.pythonhosted.org/packages/80/85/a34d1888d97247da6c2ff6118c3a721c73ed8cc4dd198c00208bb73b6f80/wrapt-2.2.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cf3638274ab9d9b724c9baa0b4c04e132cd6faefb78b4dd3dd1a02a4bdaad41e", size = 166316, upload-time = "2026-05-22T14:48:56.065Z" }, + { url = "https://files.pythonhosted.org/packages/e9/d7/72ffaeb01eebc704afe3fb99e840480f4bda45f0fa66e3381b6a39251c8f/wrapt-2.2.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:aed9658797d0b45d6c49adcfc6b41f66e6f2d0c6de3ec79e16cf4b1855df240f", size = 157952, upload-time = "2026-05-22T14:48:57.924Z" }, + { url = "https://files.pythonhosted.org/packages/24/5b/36f5d6b024e4edfdd90b140742d11ebcf7836daf5c9daf326c55c24db412/wrapt-2.2.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1d676ee388bc42a04d56dd7deb5605244dac2e35cc2fadbb43c9fa25bbd93508", size = 166130, upload-time = "2026-05-22T14:48:59.384Z" }, + { url = "https://files.pythonhosted.org/packages/81/06/9296d9e97bfdef5483dfcc859d57b095b257144b2bc5300ab521e06f4bc7/wrapt-2.2.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e395f7bc31851ef9b612050368cb446e9bc14cd7454b025018980349caf25ae5", size = 156604, upload-time = "2026-05-22T14:49:00.921Z" }, + { url = "https://files.pythonhosted.org/packages/53/37/16953929ed6776175720e58fc966e779926d8d71e2c7b2273230590ca71f/wrapt-2.2.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5f1845c2a8cc1180ccccfa45785dd06f562730d19ef75be180334254012b6283", size = 166007, upload-time = "2026-05-22T14:49:02.332Z" }, + { url = "https://files.pythonhosted.org/packages/b9/73/20ee58c0612dae7c31131a7095345812ed2c7b389019e175f68cde34e5b4/wrapt-2.2.1-cp314-cp314-win32.whl", hash = "sha256:436addbc4bb4fc0a88c702577f51195d7d73683a7f3e0e5b253d8404d7847243", size = 78327, upload-time = "2026-05-22T14:49:03.722Z" }, + { url = "https://files.pythonhosted.org/packages/22/b3/ef7c3295d02e0448a71c639a36a057f46d524d057c9486291a7a3039e65c/wrapt-2.2.1-cp314-cp314-win_amd64.whl", hash = "sha256:50972a1d974ea07725a7f6b1cec5f8759008afd030a0024843ebe7d52de47f2b", size = 81144, upload-time = "2026-05-22T14:49:05.093Z" }, + { url = "https://files.pythonhosted.org/packages/ac/dc/7bdf336953f99f4ceb0a584bb8870e42c8f26f93ea10c87834dad62f1668/wrapt-2.2.1-cp314-cp314-win_arm64.whl", hash = "sha256:1c9934ea5d92957e3cd0adbc0845539dccfd62710ebe16195a8c66c53954db36", size = 79569, upload-time = "2026-05-22T14:49:06.413Z" }, + { url = "https://files.pythonhosted.org/packages/6a/6d/6dfae80150ff1919c356d1dd528f049bcdfaae29b4d284bc957e022caef4/wrapt-2.2.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:17de18fc12cea55b8a9587314cb830573e37fb33b247a7515696350863714188", size = 82892, upload-time = "2026-05-22T14:49:07.925Z" }, + { url = "https://files.pythonhosted.org/packages/82/7b/4e34766a7d7804ffce9e71befe47e9b3225dc350c49c94493c4ab39fd3a5/wrapt-2.2.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a9dec1aca52dddde7df94818310fa2fe79739c8f385b2014c4cb1035f5508199", size = 83333, upload-time = "2026-05-22T14:49:09.257Z" }, + { url = "https://files.pythonhosted.org/packages/9d/57/0b34db3e8de44ccfece62d7b337abd1631dd810f5adc5f3db571727836b5/wrapt-2.2.1-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:69f2e9244542cb34dd59c7f073445b9e54ad9f3fce8d93606c368a1b499fc413", size = 202899, upload-time = "2026-05-22T14:49:10.572Z" }, + { url = "https://files.pythonhosted.org/packages/e5/45/ac0c459f154b99d92789a6cba7ca727185b83513b986f8ec7fe2aacddcbf/wrapt-2.2.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2d83966dc7f4f45e8b97b5933685ac2e6e67fc0e19246ea314bceb9a8970c956", size = 209986, upload-time = "2026-05-22T14:49:12.229Z" }, + { url = "https://files.pythonhosted.org/packages/b7/e4/77e37ff33ad018fa81ade52c25fa327b80b56f81d734279a63614fcb4cbc/wrapt-2.2.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:78b0aa6bfb7be8deed0ab23e7aa028cc5210c29bc2d32a04d52b50e517a7307e", size = 194893, upload-time = "2026-05-22T14:49:14.139Z" }, + { url = "https://files.pythonhosted.org/packages/dd/9d/7ea651d1ab032fc5fa222fbec91d0f8a1397f6ae04ebb93fa7219aa921d7/wrapt-2.2.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:05d5cb74d1b232ec8cfa130a8f900708699ff2491d97b8f85a4cdc5996294b85", size = 205636, upload-time = "2026-05-22T14:49:15.714Z" }, + { url = "https://files.pythonhosted.org/packages/09/af/8e88031a701275b9085c54e64bc88c0b1cd55c77eadd400691c371cd76c4/wrapt-2.2.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f6518b94edb9150452e9aba08027d4cc293433753ec1fbefb4629a21cbc74181", size = 192267, upload-time = "2026-05-22T14:49:17.283Z" }, + { url = "https://files.pythonhosted.org/packages/bf/a8/e657ca876b06710194f243d81c4b0896ade646e244bdbec2d87c8c56a8bd/wrapt-2.2.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ed55af48b3eb28f43228ca2306788892bcb629eb2b5c4876e2a3659872c2f17a", size = 198378, upload-time = "2026-05-22T14:49:18.785Z" }, + { url = "https://files.pythonhosted.org/packages/c8/59/822efe4ea722a3961331bfa35b7d90937790d2c20f0616de1997ccc3aebd/wrapt-2.2.1-cp314-cp314t-win32.whl", hash = "sha256:2e08688ab16525897da6589d56d0aebaf417bbe91c2d8e3b96203b1efa596e85", size = 80226, upload-time = "2026-05-22T14:49:20.264Z" }, + { url = "https://files.pythonhosted.org/packages/ab/31/2a7dc5f6abb2fca0b6e1610e120419f603650aceb4f1d3ac4cae0354e162/wrapt-2.2.1-cp314-cp314t-win_amd64.whl", hash = "sha256:fd0135d34387f5fd087d9be368ea77ea89cf2451dc1cd1c622d35021bcb3ab50", size = 83835, upload-time = "2026-05-22T14:49:21.634Z" }, + { url = "https://files.pythonhosted.org/packages/9f/c0/782b86e28d1ceebeb74cccea12d2cd3d2ba0bd68e3dec20b1bc5873f6127/wrapt-2.2.1-cp314-cp314t-win_arm64.whl", hash = "sha256:f70db64e8266d7c45d3b735f2e08eeb434b5e03da9a479ae42b2e2e486a21a00", size = 80722, upload-time = "2026-05-22T14:49:23.59Z" }, { url = "https://files.pythonhosted.org/packages/53/46/29ac9daf11a86c22a8c38cd9236c62928ccae83f7ceb06bd3b0467cf9d05/wrapt-2.2.1-py3-none-any.whl", hash = "sha256:3aafea2975caef8ca49400640dde02cc7426e798f24870ed01f490bc3cffd32f", size = 61000, upload-time = "2026-05-22T14:49:41.593Z" }, ] @@ -7529,6 +7274,40 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e7/2c/d6a6c9a61549f7b6c7e6dc6937d195bcf069582b47b7200dcd0e7b256acf/yarl-1.24.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:810e19b685c8c3c5862f6a38160a1f4e4c0916c9390024ec347b6157a45a0992", size = 107362, upload-time = "2026-05-19T21:29:51Z" }, { url = "https://files.pythonhosted.org/packages/92/dd/3ae5fe417e9d1c353a548553326eb9935e76b6b727161563b424cc296df3/yarl-1.24.2-cp313-cp313-win_amd64.whl", hash = "sha256:7d37fb7c38f2b6edab0f845c4f85148d4c44204f52bc127021bd2bc9fdbf1656", size = 92667, upload-time = "2026-05-19T21:29:52.743Z" }, { url = "https://files.pythonhosted.org/packages/10/cc/a7beb239f78f27fca1b053c8e8595e4179c02e62249b4687ec218c370c50/yarl-1.24.2-cp313-cp313-win_arm64.whl", hash = "sha256:1e831894be7c2954240e49791fa4b50c05a0dc881de2552cfe3ffd8631c7f461", size = 87069, upload-time = "2026-05-19T21:29:54.442Z" }, + { url = "https://files.pythonhosted.org/packages/40/0e/e08087695fc12789263821c5dc0f8dc52b5b17efd0887cacf419f8a43ba3/yarl-1.24.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:f9312b3c02d9b3d23840f67952913c9c8721d7f1b7db305289faefa878f364c2", size = 129670, upload-time = "2026-05-19T21:29:56.631Z" }, + { url = "https://files.pythonhosted.org/packages/3a/98/ab4b5ed1b1b5cd973c8a3eb994c3a6aefb6ce6d399e21bb5f0316c33815c/yarl-1.24.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a4f4d6cd615823bfc7fb7e9b5987c3f41666371d870d51058f77e2680fbe9630", size = 91916, upload-time = "2026-05-19T21:29:58.645Z" }, + { url = "https://files.pythonhosted.org/packages/ba/b1/5297bb6a7df4782f7605bffc43b31f5044070935fbbcaa6c705a07e6ac65/yarl-1.24.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0c3063e5c0a8e8e62fae6c2596fa01da1561e4cd1da6fec5789f5cf99a8aefd8", size = 91625, upload-time = "2026-05-19T21:30:00.412Z" }, + { url = "https://files.pythonhosted.org/packages/02/a7/45baabfff76829264e623b185cff0c340d7e11bf3e1cd9ea37e7d17934bd/yarl-1.24.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fecd17873a096036c1c87ab3486f1aef7f269ada7f23f7f856f93b1cc7744f14", size = 104574, upload-time = "2026-05-19T21:30:02.544Z" }, + { url = "https://files.pythonhosted.org/packages/f3/40/3a5ab144d3d650ca37d4f4b57e56169be8af3ca34c448793e064b30baaed/yarl-1.24.2-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a46d1ab4ba4d32e6dc80daf8a28ce0bd83d08df52fbc32f3e288663427734535", size = 97534, upload-time = "2026-05-19T21:30:04.319Z" }, + { url = "https://files.pythonhosted.org/packages/9c/b5/5658fef3681fb5776b4513b052bec750009f47b3a592251c705d75375798/yarl-1.24.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:73e68edf6dfd5f73f9ca127d84e2a6f9213c65bdffb736bda19524c0564fcd14", size = 111481, upload-time = "2026-05-19T21:30:05.988Z" }, + { url = "https://files.pythonhosted.org/packages/4c/06/fdcd7dde037f00866dce123ed4ba23dba94beb56fc4cf561668d27be37f2/yarl-1.24.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a296ca617f2d25fbceafb962b88750d627e5984e75732c712154d058ae8d79a3", size = 111529, upload-time = "2026-05-19T21:30:07.738Z" }, + { url = "https://files.pythonhosted.org/packages/c2/53/d81269aaafccea0d33396c03035de997b743f11e648e6e27a0df99c72980/yarl-1.24.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e51b2cf5ec89a8b8470177641ed62a3ba22d74e1e898e06ad53aa77972487208", size = 107338, upload-time = "2026-05-19T21:30:09.713Z" }, + { url = "https://files.pythonhosted.org/packages/ae/04/23049463f729bd899df203a7960505a75333edd499cda8aa1d5a82b64df5/yarl-1.24.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:310fc687f7b2044ec54e372c8cbe923bb88f5c37bded0d3079e5791c2fc3cf50", size = 106147, upload-time = "2026-05-19T21:30:11.365Z" }, + { url = "https://files.pythonhosted.org/packages/14/18/04a4b5830b43ed5e4c5015b40e9f6241ad91487d71611061b4e111d6ac80/yarl-1.24.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:297a2fe352ecf858b30a98f87948746ec16f001d279f84aebdbd3bd965e2f1bd", size = 104272, upload-time = "2026-05-19T21:30:12.978Z" }, + { url = "https://files.pythonhosted.org/packages/5a/f7/8cffdf319aee7a7c1dbd07b61d91c3e3fda460c7a93b5f93e445f3806c4c/yarl-1.24.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2a263e76b97bc42bdcd7c5f4953dec1f7cd62a1112fa7f869e57255229390d67", size = 99962, upload-time = "2026-05-19T21:30:15.001Z" }, + { url = "https://files.pythonhosted.org/packages/d7/39/b3cce3b7dbef64ac700ad4cea156a207d01bede0f507587616c364b5468e/yarl-1.24.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:822519b64cf0b474f1a0aaef1dc621438ea46bb77c94df97a5b4d213a7d8a8b1", size = 111063, upload-time = "2026-05-19T21:30:16.683Z" }, + { url = "https://files.pythonhosted.org/packages/a1/ea/100818505e7ebf165c7242ff17fdf7d9fee79e27234aeca871c1082920d7/yarl-1.24.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:b6067060d9dc594899ba83e6db6c48c68d1e494a6dab158156ed86977ca7bcb1", size = 105438, upload-time = "2026-05-19T21:30:18.769Z" }, + { url = "https://files.pythonhosted.org/packages/8f/d2/e075a0b32aa6625087de9e653087df0759fed5de4a435fef594181102a77/yarl-1.24.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:0063adad533e57171b79db3943b229d40dfafeeee579767f96541f106bac5f1b", size = 111458, upload-time = "2026-05-19T21:30:21.024Z" }, + { url = "https://files.pythonhosted.org/packages/e6/5c/ceea7ba98b65c8eb8d947fdc52f9bedfcd43c6a57c9e3c90c17be8f324a3/yarl-1.24.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ee8e3fb34513e8dc082b586ef4910c98335d43a6fab688cd44d4851bacfce3e8", size = 107589, upload-time = "2026-05-19T21:30:23.412Z" }, + { url = "https://files.pythonhosted.org/packages/fa/d9/5582d57e2b2db9b85eb6663a22efdd78e08805f3f5389566e9fcad254d1b/yarl-1.24.2-cp314-cp314-win_amd64.whl", hash = "sha256:afb00d7fd8e0f285ca29a44cc50df2d622ff2f7a6d933fa641577b5f9d5f3db0", size = 94424, upload-time = "2026-05-19T21:30:25.425Z" }, + { url = "https://files.pythonhosted.org/packages/92/10/7dc07a0e22806a9280f42a57361395506e800c64e22737cd7b0886feab42/yarl-1.24.2-cp314-cp314-win_arm64.whl", hash = "sha256:68cf6eacd6028ef1142bc4b48376b81566385ca6f9e7dde3b0fa91be08ffcb57", size = 88690, upload-time = "2026-05-19T21:30:27.623Z" }, + { url = "https://files.pythonhosted.org/packages/9e/13/d5b8e2c8667db955bcb3de233f18798fefe7edf1d7429c2c9d4f9c401114/yarl-1.24.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:221ce1dd921ac4f603957f17d7c18c5cc0797fbb52f156941f92e04605d1d67b", size = 136248, upload-time = "2026-05-19T21:30:29.297Z" }, + { url = "https://files.pythonhosted.org/packages/de/46/a4a97c05c9c9b8fd266bb2a0df12992c7fbd02391eb9640583411b6dab32/yarl-1.24.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:5f3224db28173a00d7afacdee07045cc4673dfab2b15492c7ae10deddbece761", size = 95084, upload-time = "2026-05-19T21:30:31.031Z" }, + { url = "https://files.pythonhosted.org/packages/95/b2/845cf2074a015e6fe0d0808cf1a2d9e868386c4220d657ebd8302b199043/yarl-1.24.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c557165320d6244ebe3a02431b2a201a20080e02f41f0cfa0ccc47a183765da8", size = 95272, upload-time = "2026-05-19T21:30:33.062Z" }, + { url = "https://files.pythonhosted.org/packages/fe/16/e69d4aa244aef45235ddfebc0e04036a6829842bc5a6a795aedc6c998d23/yarl-1.24.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:904065e6e85b1fa54d0d87438bd58c14c0bad97aad654ad1077fd9d87e8478ed", size = 101497, upload-time = "2026-05-19T21:30:34.842Z" }, + { url = "https://files.pythonhosted.org/packages/15/94/c07107715d621076863ee88b3ddf183fa5e9d4aba5769623c9979828410a/yarl-1.24.2-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8cec2a38d70edc10e0e856ceda886af5327a017ccbde8e1de1bd44d300357543", size = 94002, upload-time = "2026-05-19T21:30:37.724Z" }, + { url = "https://files.pythonhosted.org/packages/a9/35/fc1bbdd895b5e4010b8fdd037f7ed3aa289d3863e08231b30231ca9a0815/yarl-1.24.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e7484b9361ed222ee1ca5b4337aa4cbdcc4618ce5aff57d9ef1582fd95893fc0", size = 106524, upload-time = "2026-05-19T21:30:40.196Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f2/32b66d0a4ba47c296cf86d03e2c67bff58399fe6d6d84d5205c04c66cc6d/yarl-1.24.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:84f9670b89f34db07f81e53aee83e0b938a3412329d51c8f922488be7fcc4024", size = 106165, upload-time = "2026-05-19T21:30:41.888Z" }, + { url = "https://files.pythonhosted.org/packages/95/47/37cb5ff50c5e825d4d38e81bb04d1b7e96bf960f7ab89f9850b162f3f114/yarl-1.24.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:abb2759733d63a28b4956500a5dd57140f26486c92b2caedfb964ab7d9b79dbf", size = 103010, upload-time = "2026-05-19T21:30:43.985Z" }, + { url = "https://files.pythonhosted.org/packages/6f/d2/4597912315096f7bb359e46e13bf8b60994fcbb2db29b804c0902ef4eff5/yarl-1.24.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:081c2bf54efe03774d0311172bc04fedf9ca01e644d4cd8c805688e527209bdc", size = 101128, upload-time = "2026-05-19T21:30:46.291Z" }, + { url = "https://files.pythonhosted.org/packages/b9/d5/c8e86e120521e646013d02a8e3b8884392e28494be8f392366e50d208efc/yarl-1.24.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:86746bef442aa479107fe28132e1277237f9c24c2f00b0b0cf22b3ee0904f2bb", size = 101382, upload-time = "2026-05-19T21:30:48.085Z" }, + { url = "https://files.pythonhosted.org/packages/fa/98/70b229236118f89dbeb739b76f10225bbf53b5497725502594c9a01d699a/yarl-1.24.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:2d07d21d0bc4b17558e8de0b02fbfdf1e347d3bb3699edd00bb92e7c57925420", size = 95964, upload-time = "2026-05-19T21:30:49.785Z" }, + { url = "https://files.pythonhosted.org/packages/87/f8/56c386981e3c8648d279fdef2397ffec577e8320fd5649745e34d54faeb7/yarl-1.24.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:4fb1ac3fc5fecd8ae7453ea237e4d22b49befa70266dfe1629924245c21a0c7f", size = 106204, upload-time = "2026-05-19T21:30:51.862Z" }, + { url = "https://files.pythonhosted.org/packages/1a/1e/765afe97811ca35933e2a7de70ac57b1997ea2e4ee895719ee7a231fb7e5/yarl-1.24.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:4da31a5512ed1729ca8d8aacde3f7faeb8843cde3165d6bcf7f88f74f17bb8aa", size = 101510, upload-time = "2026-05-19T21:30:53.62Z" }, + { url = "https://files.pythonhosted.org/packages/ee/78/393913f4b9039e1edd09ae8a9bbb9d539be909a8abf6d8a2084585bed4b7/yarl-1.24.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:533ded4dceb5f1f3da7906244f4e82cf46cfd40d84c69a1faf5ac506aa65ecbe", size = 105584, upload-time = "2026-05-19T21:30:55.962Z" }, + { url = "https://files.pythonhosted.org/packages/78/87/deb17b7049bbe74ea11a713b86f8f27800cc1c8648b0b797243ebb4830ba/yarl-1.24.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:7b3a85525f6e7eeabcfdd372862b21ee1915db1b498a04e8bf0e389b607ff0bd", size = 103410, upload-time = "2026-05-19T21:30:57.962Z" }, + { url = "https://files.pythonhosted.org/packages/8f/be/f9f7594e23b5b93affff0318e4593c1920331bcaefda326cabcad94296a1/yarl-1.24.2-cp314-cp314t-win_amd64.whl", hash = "sha256:a7624b1ca46ca5d7b864ef0d2f8efe3091454085ee1855b4e992314529972215", size = 102980, upload-time = "2026-05-19T21:30:59.735Z" }, + { url = "https://files.pythonhosted.org/packages/65/a4/ba80dccd3593ff1f01051a818694d07b58cb8232677ee9a22a5a1f93a9fc/yarl-1.24.2-cp314-cp314t-win_arm64.whl", hash = "sha256:e434a45ce2e7a947f951fc5a8944c8cc080b7e59f9c50ae80fd39107cf88126d", size = 91219, upload-time = "2026-05-19T21:31:01.934Z" }, { url = "https://files.pythonhosted.org/packages/fd/4d/4b880086bd0d3e034d25647be1d830afc3e3f610e98c4ab3490af6b1b6d5/yarl-1.24.2-py3-none-any.whl", hash = "sha256:2783d9226db8797636cd6896e4de81feed252d1db72265686c9558d97a4d94b9", size = 53576, upload-time = "2026-05-19T21:31:03.909Z" }, ] From 81a74c92b21e2be6a980f619392cdd46b4700dd4 Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 16:01:16 -0700 Subject: [PATCH 25/72] feat(dynacell): DynaCell v1.1 benchmark configs from dynacell-models Port every DynaCell config path of dynacell-models verbatim: the model leaves (baselines, A549/joint/HEK/brightfield, the 2D track with its seed replicates and warmup-matched refit, the temporal and patch-vs-augmentation ablations, CELL-Diff-R2 and the DynaCell-lite leaves), the grouped and instance-AP eval buckets of the paper models, the shared overlays, train/predict sets and launcher profiles, and the deletion of 155 stale config files. The leaves are generated; review the generators and guard tests in the code commits, not each leaf. Spotlight v2 arm leaves, their four fit overlays and their 231 spotlight_v2_* eval buckets are left out; they follow in their own PR. Co-Authored-By: Claude Opus 5.5 --- applications/dynacell/configs/README.md | 26 + .../dynacell/configs/benchmarks/README.md | 15 + .../benchmarks/virtual_staining/README.md | 64 +- .../predict__a549_mantis_denv.yml | 2 +- .../predict__a549_mantis_mock.yml | 2 +- .../predict__a549_mantis_zikv.yml | 2 +- .../predict__hek_mantis_kras_a549xy.yml | 57 ++ .../predict__ipsc_confocal.yml | 2 +- .../predict__ipsc_confocal_smoke.yml | 2 +- .../predict__a549_mantis_denv.yml | 4 +- .../predict__a549_mantis_mock.yml | 4 +- .../predict__a549_mantis_zikv.yml | 4 +- .../predict__ipsc_confocal.yml | 4 +- .../a549_mantis/predict__a549_mantis_denv.yml | 2 +- .../a549_mantis/predict__a549_mantis_mock.yml | 2 +- .../a549_mantis/predict__a549_mantis_zikv.yml | 2 +- .../a549_mantis/predict__ipsc_confocal.yml | 2 +- .../vscyto3d_cytolandft/a549_mantis/train.yml | 2 + .../predict__a549_mantis_denv.yml | 2 +- .../predict__a549_mantis_mock.yml | 2 +- .../predict__a549_mantis_zikv.yml | 2 +- .../ipsc_confocal/predict__ipsc_confocal.yml | 2 +- .../ipsc_confocal/train.yml | 2 + .../a549_mantis/predict__a549_mantis_denv.yml | 2 +- .../a549_mantis/predict__a549_mantis_mock.yml | 2 +- .../a549_mantis/predict__a549_mantis_zikv.yml | 2 +- .../a549_mantis/predict__ipsc_confocal.yml | 2 +- .../a549_mantis/train.yml | 4 +- .../predict__a549_mantis_denv.yml | 2 +- .../predict__a549_mantis_mock.yml | 2 +- .../predict__a549_mantis_zikv.yml | 2 +- .../ipsc_confocal/predict__ipsc_confocal.yml | 2 +- .../ipsc_confocal/train.yml | 4 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../phase/eval__a549_mantis_sec61b_denv.yaml | 21 + .../phase/eval__a549_mantis_sec61b_mock.yaml | 21 + .../phase/eval__a549_mantis_sec61b_zikv.yaml | 21 + .../leaf/er/phase/eval__ipsc_confocal.yaml | 16 + .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 1 - .../_internal/leaf/grouped/README.md | 12 +- .../leaf/grouped/_probe/eval_grouped.yaml | 52 +- .../eval_grouped.yaml | 167 ++++ .../er_a549_bf_trained/eval_grouped.yaml | 94 ++ .../grouped/er_a549_trained/eval_grouped.yaml | 178 +++- .../er_a549_trained__2d/eval_grouped.yaml | 282 ++++++ .../eval_grouped.yaml | 265 +++++ .../eval_grouped.yaml | 542 ++++++++++ .../er_a549_trained__lite/eval_grouped.yaml | 219 ++++ .../eval_grouped.yaml | 92 ++ .../er_ipsc_bf_trained/eval_grouped.yaml | 94 ++ .../grouped/er_ipsc_trained/eval_grouped.yaml | 156 +-- .../er_ipsc_trained__2d/eval_grouped.yaml | 282 ++++++ .../eval_grouped.yaml | 265 +++++ .../eval_grouped.yaml | 542 ++++++++++ .../eval_grouped.yaml | 77 ++ .../eval_grouped.yaml | 76 ++ .../er_ipsc_trained__lite/eval_grouped.yaml | 219 ++++ .../leaf/grouped/er_joint/eval_grouped.yaml | 178 +++- .../grouped/er_joint__2d/eval_grouped.yaml | 282 ++++++ .../er_joint__2d_focus2d/eval_grouped.yaml | 265 +++++ .../er_joint__2d_focusslab3/eval_grouped.yaml | 542 ++++++++++ .../grouped/er_joint__lite/eval_grouped.yaml | 59 ++ .../eval_grouped.yaml | 74 ++ .../eval_grouped.yaml | 74 ++ .../eval_grouped.yaml | 202 ++++ .../membrane_a549_trained/eval_grouped.yaml | 154 ++- .../eval_grouped.yaml | 301 ++++++ .../eval_grouped.yaml | 251 +++++ .../eval_grouped.yaml | 183 ++++ .../eval_grouped.yaml | 237 ----- .../membrane_hek_a549xy/eval_grouped.yaml | 152 +++ .../eval_grouped.yaml | 66 ++ .../eval_grouped.yaml | 64 ++ .../membrane_ipsc_trained/eval_grouped.yaml | 196 ++-- .../eval_grouped.yaml | 301 ++++++ .../eval_grouped.yaml | 251 +++++ .../eval_grouped.yaml | 211 ++++ .../eval_grouped.yaml | 223 +++++ .../eval_grouped.yaml | 300 ------ .../grouped/membrane_joint/eval_grouped.yaml | 169 ++-- .../membrane_joint__2d/eval_grouped.yaml | 301 ++++++ .../eval_grouped.yaml | 251 +++++ .../membrane_joint__lite/eval_grouped.yaml | 63 ++ .../membrane_joint_carved/eval_grouped.yaml | 194 ---- .../eval_grouped.yaml | 72 ++ .../eval_grouped.yaml | 167 ++++ .../eval_grouped.yaml | 178 +++- .../eval_grouped.yaml | 282 ++++++ .../eval_grouped.yaml | 265 +++++ .../eval_grouped.yaml | 542 ++++++++++ .../eval_grouped.yaml | 219 ++++ .../mitochondria_hek_a549xy/eval_grouped.yaml | 103 ++ .../eval_grouped.yaml | 49 + .../eval_grouped.yaml | 55 + .../eval_grouped.yaml | 174 ++-- .../eval_grouped.yaml | 282 ++++++ .../eval_grouped.yaml | 265 +++++ .../eval_grouped.yaml | 542 ++++++++++ .../eval_grouped.yaml | 219 ++++ .../mitochondria_joint/eval_grouped.yaml | 178 +++- .../mitochondria_joint__2d/eval_grouped.yaml | 282 ++++++ .../eval_grouped.yaml | 265 +++++ .../eval_grouped.yaml | 542 ++++++++++ .../eval_grouped.yaml | 59 ++ .../eval_grouped.yaml | 74 ++ .../eval_grouped.yaml | 74 ++ .../eval_grouped.yaml | 189 ++++ .../nucleus_a549_bf_trained/eval_grouped.yaml | 97 ++ .../nucleus_a549_trained/eval_grouped.yaml | 122 +-- .../eval_grouped.yaml | 285 ++++++ .../eval_grouped.yaml | 234 +++++ .../eval_grouped.yaml | 182 ++++ .../eval_grouped.yaml | 95 ++ .../nucleus_ipsc_bf_trained/eval_grouped.yaml | 97 ++ .../eval_grouped.yaml | 113 +++ .../nucleus_ipsc_trained/eval_grouped.yaml | 158 +-- .../eval_grouped.yaml | 285 ++++++ .../eval_grouped.yaml | 234 +++++ .../eval_grouped.yaml | 197 ++++ .../eval_grouped.yaml | 80 ++ .../eval_grouped.yaml | 79 ++ .../eval_grouped.yaml | 222 +++++ .../eval_grouped.yaml | 113 +++ .../grouped/nucleus_joint/eval_grouped.yaml | 122 +-- .../nucleus_joint__2d/eval_grouped.yaml | 285 ++++++ .../eval_grouped.yaml | 234 +++++ .../nucleus_joint__lite/eval_grouped.yaml | 62 ++ .../eval_grouped.yaml | 67 ++ .../membrane_a549/eval_grouped.yaml | 515 +++++++--- .../membrane_ipsc/eval_grouped.yaml | 155 ++- .../nucleus_a549/eval_grouped.yaml | 455 ++++++--- .../nucleus_ipsc/eval_grouped.yaml | 167 +++- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../cytoland/eval__a549_mantis.yaml | 10 +- .../cytoland/eval__ipsc_confocal.yaml | 4 +- .../infectionft/eval__a549_mantis.yaml | 10 +- .../infectionft/eval__ipsc_confocal.yaml | 4 +- .../randinit/eval__a549_mantis.yaml | 10 +- .../randinit/eval__ipsc_confocal.yaml | 4 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../phase/eval__a549_mantis_caax_denv.yaml | 25 + .../phase/eval__a549_mantis_caax_mock.yaml | 25 + .../phase/eval__a549_mantis_caax_zikv.yaml | 25 + .../membrane/phase/eval__ipsc_confocal.yaml | 21 + .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 1 - .../a549_mantis/eval__a549_mantis.yaml | 10 +- .../a549_mantis/eval__ipsc_confocal.yaml | 4 +- .../ipsc_confocal/eval__a549_mantis.yaml | 10 +- .../ipsc_confocal/eval__ipsc_confocal.yaml | 4 +- .../a549_mantis/eval__a549_mantis.yaml | 10 +- .../a549_mantis/eval__ipsc_confocal.yaml | 4 +- .../ipsc_confocal/eval__a549_mantis.yaml | 10 +- .../ipsc_confocal/eval__ipsc_confocal.yaml | 4 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../phase/eval__a549_mantis_tomm20_denv.yaml | 21 + .../phase/eval__a549_mantis_tomm20_mock.yaml | 21 + .../phase/eval__a549_mantis_tomm20_zikv.yaml | 21 + .../leaf/mito/phase/eval__ipsc_confocal.yaml | 16 + .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../cytoland/eval__a549_mantis.yaml | 2 +- .../cytoland/eval__ipsc_confocal.yaml | 2 +- .../infectionft/eval__a549_mantis.yaml | 2 +- .../infectionft/eval__ipsc_confocal.yaml | 2 +- .../randinit/eval__a549_mantis.yaml | 2 +- .../randinit/eval__ipsc_confocal.yaml | 2 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../phase/eval__a549_mantis_h2b_denv.yaml | 22 + .../phase/eval__a549_mantis_h2b_mock.yaml | 22 + .../phase/eval__a549_mantis_h2b_zikv.yaml | 22 + .../nucleus/phase/eval__ipsc_confocal.yaml | 19 + .../ipsc_confocal/eval__a549_mantis_denv.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 1 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 1 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 1 - .../a549_mantis/eval__a549_mantis.yaml | 2 +- .../a549_mantis/eval__ipsc_confocal.yaml | 2 +- .../ipsc_confocal/eval__a549_mantis.yaml | 2 +- .../ipsc_confocal/eval__ipsc_confocal.yaml | 2 +- .../a549_mantis/eval__a549_mantis.yaml | 2 +- .../a549_mantis/eval__ipsc_confocal.yaml | 2 +- .../ipsc_confocal/eval__a549_mantis.yaml | 2 +- .../ipsc_confocal/eval__ipsc_confocal.yaml | 2 +- .../eval_grouped.yaml | 36 + .../eval_grouped.yaml | 36 + .../eval_grouped.yaml | 36 + .../er_a549_trained__ipsc/eval_grouped.yaml | 36 + .../eval_grouped.yaml | 36 + .../eval_grouped.yaml | 36 + .../eval_grouped.yaml | 36 + .../er_ipsc_trained__ipsc/eval_grouped.yaml | 36 + .../er_joint__a549_denv/eval_grouped.yaml | 36 + .../er_joint__a549_mock/eval_grouped.yaml | 36 + .../er_joint__a549_zikv/eval_grouped.yaml | 36 + .../er_joint__ipsc/eval_grouped.yaml | 36 + .../eval_grouped.yaml | 41 + .../eval_grouped.yaml | 41 + .../eval_grouped.yaml | 41 + .../eval_grouped.yaml | 40 + .../eval_grouped.yaml | 41 + .../eval_grouped.yaml | 41 + .../eval_grouped.yaml | 41 + .../eval_grouped.yaml | 40 + .../eval_grouped.yaml | 41 + .../eval_grouped.yaml | 41 + .../eval_grouped.yaml | 41 + .../membrane_joint__ipsc/eval_grouped.yaml | 40 + .../eval_grouped.yaml | 36 + .../eval_grouped.yaml | 36 + .../eval_grouped.yaml | 36 + .../eval_grouped.yaml | 36 + .../eval_grouped.yaml | 37 + .../eval_grouped.yaml | 42 + .../eval_grouped.yaml | 37 + .../eval_grouped.yaml | 37 + .../eval_grouped.yaml | 36 + .../eval_grouped.yaml | 36 + .../eval_grouped.yaml | 36 + .../eval_grouped.yaml | 36 + .../eval_grouped.yaml | 39 + .../eval_grouped.yaml | 39 + .../eval_grouped.yaml | 39 + .../eval_grouped.yaml | 39 + .../eval_grouped.yaml | 39 + .../eval_grouped.yaml | 39 + .../eval_grouped.yaml | 39 + .../eval_grouped.yaml | 39 + .../eval_grouped.yaml | 39 + .../eval_grouped.yaml | 39 + .../eval_grouped.yaml | 39 + .../nucleus_joint__ipsc/eval_grouped.yaml | 39 + .../model/data_overlays/celldiff_2d_fit.yml | 78 ++ .../data_overlays/fcmae_vscyto2d_fit.yml | 78 ++ .../shared/model/data_overlays/fnet2d_fit.yml | 58 ++ .../data_overlays/fnet3d_bigpatch_fit.yml | 73 ++ .../data_overlays/fnet3d_vscyto3daug_fit.yml | 105 ++ .../data_overlays/pix2pix2d_unetvit_fit.yml | 87 ++ .../launcher_profiles/hardware_4gpu_long.yml | 52 + .../hardware_predict_any_gpu.yml | 34 +- .../hardware_predict_celldiff.yml | 32 + .../hardware_predict_celldiff_lite.yml | 20 + .../hardware_predict_h200.yml | 42 + .../model/model_overlays/celldiff_2d_fit.yml | 65 ++ .../model_overlays/celldiff_2d_predict.yml | 35 + .../model_overlays/celldiff_predict_lite.yml | 40 + .../model_overlays/fcmae_vscyto2d_fit.yml | 68 ++ .../model_overlays/fcmae_vscyto2d_predict.yml | 49 + .../fcmae_vscyto3d_2chan_fit.yml | 1 + .../model_overlays/fcmae_vscyto3d_fit.yml | 18 +- .../model/model_overlays/fnet2d_fit.yml | 25 + .../model/model_overlays/fnet2d_predict.yml | 26 + .../model/model_overlays/fnet3d_paper_fit.yml | 5 + .../model_overlays/pix2pix2d_unetvit_fit.yml | 92 ++ .../pix2pix2d_unetvit_predict.yml | 66 ++ .../pix2pix3d_unetvit_predict.yml | 65 +- .../model_overlays/unetvit3d_predict.yml | 18 +- .../a549_mantis_caax_denv_lite.yml | 8 + .../a549_mantis_caax_mock_lite.yml | 8 + .../a549_mantis_caax_zikv_lite.yml | 8 + .../predict_sets/a549_mantis_dual_denv.yml | 6 +- .../predict_sets/a549_mantis_dual_mock.yml | 6 +- .../predict_sets/a549_mantis_dual_zikv.yml | 6 +- .../a549_mantis_h2b_denv_lite.yml | 8 + .../a549_mantis_h2b_mock_lite.yml | 8 + .../a549_mantis_h2b_zikv_lite.yml | 8 + .../a549_mantis_sec61b_denv_lite.yml | 8 + .../a549_mantis_sec61b_mock_lite.yml | 8 + .../a549_mantis_sec61b_zikv_lite.yml | 8 + .../a549_mantis_tomm20_denv_lite.yml | 8 + .../a549_mantis_tomm20_mock_lite.yml | 8 + .../a549_mantis_tomm20_zikv_lite.yml | 8 + .../predict_sets/hek_mantis_dual_a549xy.yml | 26 + .../predict_sets/hek_mantis_kras_a549xy.yml | 11 + .../hek_mantis_tomm70a_a549xy.yml | 11 + .../model/predict_sets/ipsc_confocal_lite.yml | 8 + .../train_sets/a549_mantis_brightfield.yml | 32 + .../train_sets/ipsc_confocal_brightfield.yml | 29 + .../a549_mantis/predict__a549_mantis_denv.yml | 8 +- .../predict__a549_mantis_denv_lite.yml | 36 + .../a549_mantis/predict__a549_mantis_mock.yml | 8 +- .../predict__a549_mantis_mock_lite.yml | 36 + .../a549_mantis/predict__a549_mantis_zikv.yml | 8 +- .../predict__a549_mantis_zikv_lite.yml | 36 + .../a549_mantis/predict__ipsc_confocal.yml | 8 +- .../predict__ipsc_confocal_lite.yml | 36 + .../er/celldiff/a549_mantis/train.yml | 8 +- .../predict__a549_mantis_denv.yml | 59 ++ .../predict__a549_mantis_mock.yml | 59 ++ .../predict__a549_mantis_zikv.yml | 59 ++ .../predict__ipsc_confocal__iterative.yml | 55 + .../a549_mantis_brightfield/train.yml | 71 ++ .../ipsc_confocal/eval__a549_mantis_denv.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 13 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 13 - .../predict__a549_mantis_denv.yml | 8 +- .../predict__a549_mantis_denv_lite.yml | 36 + .../predict__a549_mantis_mock.yml | 8 +- .../predict__a549_mantis_mock_lite.yml | 36 + .../predict__a549_mantis_zikv.yml | 8 +- .../predict__a549_mantis_zikv_lite.yml | 36 + .../predict__ipsc_confocal__denoise.yml | 8 +- .../predict__ipsc_confocal__iterative.yml | 8 +- ...predict__ipsc_confocal__iterative_lite.yml | 36 + ...predict__ipsc_confocal__sliding_window.yml | 8 +- .../er/celldiff/ipsc_confocal/train.yml | 6 +- .../predict__a549_mantis_denv.yml | 59 ++ .../predict__a549_mantis_mock.yml | 59 ++ .../predict__a549_mantis_zikv.yml | 59 ++ .../predict__ipsc_confocal__iterative.yml | 55 + .../ipsc_confocal_brightfield/train.yml | 65 ++ .../predict__a549_mantis_denv.yml | 8 +- .../predict__a549_mantis_denv_lite.yml | 36 + .../predict__a549_mantis_mock.yml | 8 +- .../predict__a549_mantis_mock_lite.yml | 36 + .../predict__a549_mantis_zikv.yml | 8 +- .../predict__a549_mantis_zikv_lite.yml | 36 + .../predict__ipsc_confocal.yml | 8 +- .../predict__ipsc_confocal_lite.yml | 36 + .../joint_ipsc_confocal_a549_mantis/train.yml | 10 +- .../train_smoke.yml | 2 +- .../train_smoke_4gpu.yml | 2 +- .../a549_mantis/predict__a549_mantis_denv.yml | 55 + .../a549_mantis/predict__a549_mantis_mock.yml | 55 + .../a549_mantis/predict__a549_mantis_zikv.yml | 55 + .../a549_mantis/predict__ipsc_confocal.yml | 55 + .../er/celldiff_2d/a549_mantis/train.yml | 82 ++ .../predict__a549_mantis_denv.yml | 55 + .../predict__a549_mantis_mock.yml | 55 + .../predict__a549_mantis_zikv.yml | 55 + .../ipsc_confocal/predict__ipsc_confocal.yml | 55 + .../er/celldiff_2d/ipsc_confocal/train.yml | 82 ++ .../predict__a549_mantis_denv.yml | 55 + .../predict__a549_mantis_mock.yml | 55 + .../predict__a549_mantis_zikv.yml | 55 + .../predict__ipsc_confocal.yml | 55 + .../joint_ipsc_confocal_a549_mantis/train.yml | 138 +++ .../a549_mantis/predict__a549_mantis_denv.yml | 59 ++ .../a549_mantis/predict__a549_mantis_mock.yml | 59 ++ .../a549_mantis/predict__a549_mantis_zikv.yml | 59 ++ .../a549_mantis/predict__ipsc_confocal.yml | 59 ++ .../a549_mantis/train.yml | 73 ++ .../predict__a549_mantis_denv.yml | 59 ++ .../predict__a549_mantis_mock.yml | 59 ++ .../predict__a549_mantis_zikv.yml | 59 ++ .../ipsc_confocal/predict__ipsc_confocal.yml | 59 ++ .../ipsc_confocal/train.yml | 83 ++ .../predict__a549_mantis_denv.yml | 59 ++ .../predict__a549_mantis_mock.yml | 59 ++ .../predict__a549_mantis_zikv.yml | 59 ++ .../predict__ipsc_confocal.yml | 59 ++ .../joint_ipsc_confocal_a549_mantis/train.yml | 165 +++ .../a549_mantis/predict__a549_mantis_denv.yml | 59 ++ .../a549_mantis/predict__a549_mantis_mock.yml | 59 ++ .../a549_mantis/predict__a549_mantis_zikv.yml | 59 ++ .../a549_mantis/predict__ipsc_confocal.yml | 59 ++ .../a549_mantis/train.yml | 64 ++ .../predict__a549_mantis_denv.yml | 59 ++ .../predict__a549_mantis_mock.yml | 59 ++ .../predict__a549_mantis_zikv.yml | 59 ++ .../ipsc_confocal/predict__ipsc_confocal.yml | 59 ++ .../ipsc_confocal/train.yml | 72 ++ .../predict__a549_mantis_denv.yml | 59 ++ .../predict__a549_mantis_mock.yml | 59 ++ .../predict__a549_mantis_zikv.yml | 59 ++ .../predict__ipsc_confocal.yml | 59 ++ .../joint_ipsc_confocal_a549_mantis/train.yml | 150 +++ .../predict__a549_mantis_denv.yml | 61 ++ .../predict__a549_mantis_mock.yml | 61 ++ .../predict__a549_mantis_zikv.yml | 61 ++ .../ipsc_confocal/predict__ipsc_confocal.yml | 61 ++ .../ipsc_confocal/train.yml | 86 ++ .../predict__a549_mantis_denv.yml | 2 +- .../predict__a549_mantis_mock.yml | 2 +- .../predict__a549_mantis_zikv.yml | 2 +- .../predict__ipsc_confocal.yml | 2 +- .../a549_mantis/predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 37 + .../a549_mantis/predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 37 + .../a549_mantis/predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 37 + .../a549_mantis/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../a549_mantis/train.yml | 10 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 13 - .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 37 + .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 37 + .../predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 37 + .../ipsc_confocal/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../ipsc_confocal/train.yml | 8 +- .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_zikv.yml | 6 +- .../predict__ipsc_confocal.yml | 6 +- .../joint_ipsc_confocal_a549_mantis/train.yml | 12 +- .../a549_mantis/predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 37 + .../a549_mantis/predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 37 + .../a549_mantis/predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 37 + .../a549_mantis/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../a549_mantis/train.yml | 10 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 13 - .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 37 + .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 37 + .../predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 37 + .../ipsc_confocal/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../ipsc_confocal/train.yml | 8 +- .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_zikv.yml | 6 +- .../predict__ipsc_confocal.yml | 6 +- .../joint_ipsc_confocal_a549_mantis/train.yml | 12 +- .../a549_mantis/predict__a549_mantis_denv.yml | 52 + .../a549_mantis/predict__a549_mantis_mock.yml | 52 + .../a549_mantis/predict__a549_mantis_zikv.yml | 52 + .../a549_mantis/predict__ipsc_confocal.yml | 52 + .../er/fnet2d/a549_mantis/train.yml | 56 ++ .../predict__a549_mantis_denv.yml | 52 + .../predict__a549_mantis_mock.yml | 52 + .../predict__a549_mantis_zikv.yml | 52 + .../ipsc_confocal/predict__ipsc_confocal.yml | 52 + .../er/fnet2d/ipsc_confocal/train.yml | 63 ++ .../predict__a549_mantis_denv.yml | 52 + .../predict__a549_mantis_mock.yml | 52 + .../predict__a549_mantis_zikv.yml | 52 + .../predict__ipsc_confocal.yml | 52 + .../joint_ipsc_confocal_a549_mantis/train.yml | 123 +++ .../predict__a549_mantis_denv.yml | 52 + .../predict__a549_mantis_mock.yml | 52 + .../predict__a549_mantis_zikv.yml | 52 + .../ipsc_confocal/predict__ipsc_confocal.yml | 52 + .../ipsc_confocal/train.yml | 67 ++ .../a549_mantis/predict__a549_mantis_denv.yml | 41 + .../predict__a549_mantis_denv_lite.yml | 37 + .../a549_mantis/predict__a549_mantis_mock.yml | 41 + .../predict__a549_mantis_mock_lite.yml | 37 + .../a549_mantis/predict__a549_mantis_zikv.yml | 41 + .../predict__a549_mantis_zikv_lite.yml | 37 + .../a549_mantis/predict__ipsc_confocal.yml | 41 + .../predict__ipsc_confocal_lite.yml | 37 + .../er/fnet3d_paper/a549_mantis/train.yml | 10 +- .../predict__a549_mantis_denv.yml | 60 ++ .../predict__a549_mantis_mock.yml | 60 ++ .../predict__a549_mantis_zikv.yml | 60 ++ .../predict__ipsc_confocal.yml | 56 ++ .../a549_mantis_brightfield/train.yml | 89 ++ .../ipsc_confocal/eval__a549_mantis_denv.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 13 - .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 37 + .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 37 + .../predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 37 + .../ipsc_confocal/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../er/fnet3d_paper/ipsc_confocal/train.yml | 8 +- .../predict__a549_mantis_denv.yml | 60 ++ .../predict__a549_mantis_mock.yml | 60 ++ .../predict__a549_mantis_zikv.yml | 60 ++ .../predict__ipsc_confocal.yml | 56 ++ .../ipsc_confocal_brightfield/train.yml | 79 ++ .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_zikv.yml | 6 +- .../predict__ipsc_confocal.yml | 6 +- .../joint_ipsc_confocal_a549_mantis/train.yml | 10 +- .../predict__a549_mantis_sec61b_denv.yml | 57 ++ .../predict__a549_mantis_sec61b_mock.yml | 57 ++ .../predict__a549_mantis_sec61b_zikv.yml | 57 ++ .../er/fnet3d_t01/a549_mantis/train.yml | 77 ++ .../er/fnet3d_t01/a549_mantis/train_smoke.yml | 43 + .../predict__a549_mantis_sec61b_denv.yml | 57 ++ .../predict__a549_mantis_sec61b_mock.yml | 57 ++ .../predict__a549_mantis_sec61b_zikv.yml | 57 ++ .../er/fnet3d_tspread/a549_mantis/train.yml | 79 ++ .../a549_mantis/predict__a549_mantis_denv.yml | 68 ++ .../a549_mantis/predict__a549_mantis_mock.yml | 68 ++ .../a549_mantis/predict__a549_mantis_zikv.yml | 68 ++ .../a549_mantis/predict__ipsc_confocal.yml | 68 ++ .../pix2pix2d_unetvit/a549_mantis/train.yml | 102 ++ .../pix2pix2d_unetvit/ipsc_confocal/train.yml | 102 ++ .../predict__a549_mantis_denv.yml | 68 ++ .../predict__a549_mantis_mock.yml | 68 ++ .../predict__a549_mantis_zikv.yml | 68 ++ .../predict__ipsc_confocal.yml | 68 ++ .../joint_ipsc_confocal_a549_mantis/train.yml | 170 ++++ .../a549_mantis/predict__a549_mantis_denv.yml | 42 + .../a549_mantis/predict__a549_mantis_mock.yml | 42 + .../a549_mantis/predict__a549_mantis_zikv.yml | 42 + .../a549_mantis/predict__ipsc_confocal.yml | 42 + .../a549_mantis/train.yml | 69 ++ .../predict__a549_mantis_denv.yml | 42 + .../predict__a549_mantis_mock.yml | 42 + .../predict__a549_mantis_zikv.yml | 42 + .../ipsc_confocal/predict__ipsc_confocal.yml | 42 + .../ipsc_confocal/train.yml | 69 ++ .../predict__a549_mantis_denv.yml | 42 + .../predict__a549_mantis_mock.yml | 42 + .../predict__a549_mantis_zikv.yml | 42 + .../predict__ipsc_confocal.yml | 42 + .../joint_ipsc_confocal_a549_mantis/train.yml | 207 ++++ .../a549_mantis/predict__a549_mantis_denv.yml | 48 + .../a549_mantis/predict__a549_mantis_mock.yml | 48 + .../a549_mantis/predict__a549_mantis_zikv.yml | 48 + .../a549_mantis/predict__ipsc_confocal.yml | 48 + .../pix2pix3d_unetvit/a549_mantis/train.yml | 2 + .../a549_mantis/train_4gpu_modernized.yml | 59 ++ .../ipsc_confocal/eval__a549_mantis_denv.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 13 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 13 - .../predict__a549_mantis_denv.yml | 11 +- .../predict__a549_mantis_mock.yml | 11 +- .../predict__a549_mantis_zikv.yml | 11 +- .../ipsc_confocal/predict__ipsc_confocal.yml | 11 +- .../pix2pix3d_unetvit/ipsc_confocal/train.yml | 2 + .../ipsc_confocal/train_4gpu.yml | 2 + .../ipsc_confocal/train_4gpu_modernized.yml | 2 + .../predict__a549_mantis_denv.yml | 11 +- .../predict__a549_mantis_mock.yml | 11 +- .../predict__a549_mantis_zikv.yml | 11 +- .../predict__ipsc_confocal.yml | 11 +- .../joint_ipsc_confocal_a549_mantis/train.yml | 2 + .../train_4gpu_modernized.yml | 159 +++ .../a549_mantis/predict__a549_mantis_denv.yml | 43 + .../predict__a549_mantis_denv_lite.yml | 37 + .../a549_mantis/predict__a549_mantis_mock.yml | 43 + .../predict__a549_mantis_mock_lite.yml | 37 + .../a549_mantis/predict__a549_mantis_zikv.yml | 43 + .../predict__a549_mantis_zikv_lite.yml | 37 + .../a549_mantis/predict__ipsc_confocal.yml | 43 + .../predict__ipsc_confocal_lite.yml | 37 + .../er/unetvit3d/a549_mantis/train.yml | 10 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 13 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 13 - .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 37 + .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 37 + .../predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 37 + .../ipsc_confocal/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../er/unetvit3d/ipsc_confocal/train.yml | 8 +- .../predict__a549_mantis_denv.yml | 43 + .../predict__a549_mantis_mock.yml | 43 + .../predict__a549_mantis_zikv.yml | 43 + .../predict__ipsc_confocal.yml | 43 + .../joint_ipsc_confocal_a549_mantis/train.yml | 15 +- .../er/unext2/a549_mantis/train.yml | 2 + .../er/unext2/ipsc_confocal/train.yml | 2 + .../joint_ipsc_confocal_a549_mantis/train.yml | 2 + .../a549_mantis/predict__a549_mantis_denv.yml | 8 +- .../predict__a549_mantis_denv_lite.yml | 38 + .../a549_mantis/predict__a549_mantis_mock.yml | 8 +- .../predict__a549_mantis_mock_lite.yml | 38 + .../predict__a549_mantis_movie.yml | 47 + .../a549_mantis/predict__a549_mantis_zikv.yml | 8 +- .../predict__a549_mantis_zikv_lite.yml | 38 + .../predict__hek_mantis_kras_a549xy.yml | 54 + .../a549_mantis/predict__ipsc_confocal.yml | 8 +- .../predict__ipsc_confocal_lite.yml | 36 + .../membrane/celldiff/a549_mantis/train.yml | 6 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 19 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 13 - .../predict__a549_mantis_denv.yml | 8 +- .../predict__a549_mantis_denv_lite.yml | 38 + .../predict__a549_mantis_mock.yml | 8 +- .../predict__a549_mantis_mock_lite.yml | 38 + .../predict__a549_mantis_zikv.yml | 8 +- .../predict__a549_mantis_zikv_lite.yml | 38 + .../predict__hek_mantis_kras_a549xy.yml | 54 + .../predict__ipsc_confocal__denoise.yml | 8 +- .../predict__ipsc_confocal__iterative.yml | 8 +- ...predict__ipsc_confocal__iterative_lite.yml | 36 + ...predict__ipsc_confocal__sliding_window.yml | 8 +- .../membrane/celldiff/ipsc_confocal/train.yml | 6 +- .../predict__a549_mantis_denv.yml | 8 +- .../predict__a549_mantis_denv_lite.yml | 38 + .../predict__a549_mantis_mock.yml | 8 +- .../predict__a549_mantis_mock_lite.yml | 38 + .../predict__a549_mantis_movie.yml | 9 +- .../predict__a549_mantis_zikv.yml | 8 +- .../predict__a549_mantis_zikv_lite.yml | 38 + .../predict__hek_mantis_kras_a549xy.yml | 54 + .../predict__ipsc_confocal.yml | 8 +- .../predict__ipsc_confocal_lite.yml | 36 + .../joint_ipsc_confocal_a549_mantis/train.yml | 6 +- .../a549_mantis/predict__a549_mantis_denv.yml | 59 ++ .../a549_mantis/predict__a549_mantis_mock.yml | 59 ++ .../a549_mantis/predict__a549_mantis_zikv.yml | 59 ++ .../a549_mantis/predict__ipsc_confocal.yml | 55 + .../celldiff_2d/a549_mantis/train.yml | 82 ++ .../predict__a549_mantis_denv.yml | 59 ++ .../predict__a549_mantis_mock.yml | 59 ++ .../predict__a549_mantis_zikv.yml | 59 ++ .../ipsc_confocal/predict__ipsc_confocal.yml | 55 + .../celldiff_2d/ipsc_confocal/train.yml | 82 ++ .../predict__a549_mantis_denv.yml | 59 ++ .../predict__a549_mantis_mock.yml | 59 ++ .../predict__a549_mantis_zikv.yml | 59 ++ .../predict__ipsc_confocal.yml | 55 + .../joint_ipsc_confocal_a549_mantis/train.yml | 138 +++ .../predict__a549_mantis_denv.yml | 43 + .../predict__a549_mantis_mock.yml | 43 + .../predict__a549_mantis_zikv.yml | 43 + .../ipsc_confocal/predict__ipsc_confocal.yml | 41 + .../celldiff_2d_seed1/ipsc_confocal/train.yml | 61 ++ .../a549_mantis/predict__a549_mantis_denv.yml | 63 ++ .../a549_mantis/predict__a549_mantis_mock.yml | 63 ++ .../a549_mantis/predict__a549_mantis_zikv.yml | 63 ++ .../a549_mantis/predict__ipsc_confocal.yml | 59 ++ .../a549_mantis/train.yml | 84 ++ .../predict__a549_mantis_denv.yml | 63 ++ .../predict__a549_mantis_mock.yml | 63 ++ .../predict__a549_mantis_zikv.yml | 63 ++ .../ipsc_confocal/predict__ipsc_confocal.yml | 59 ++ .../ipsc_confocal/train.yml | 93 ++ .../predict__a549_mantis_denv.yml | 63 ++ .../predict__a549_mantis_mock.yml | 63 ++ .../predict__a549_mantis_zikv.yml | 63 ++ .../predict__ipsc_confocal.yml | 59 ++ .../joint_ipsc_confocal_a549_mantis/train.yml | 165 +++ .../a549_mantis/predict__a549_mantis_denv.yml | 63 ++ .../a549_mantis/predict__a549_mantis_mock.yml | 63 ++ .../a549_mantis/predict__a549_mantis_zikv.yml | 63 ++ .../a549_mantis/predict__ipsc_confocal.yml | 59 ++ .../a549_mantis/train.yml | 75 ++ .../predict__a549_mantis_denv.yml | 63 ++ .../predict__a549_mantis_mock.yml | 63 ++ .../predict__a549_mantis_zikv.yml | 63 ++ .../ipsc_confocal/predict__ipsc_confocal.yml | 59 ++ .../ipsc_confocal/train.yml | 83 ++ .../predict__a549_mantis_denv.yml | 63 ++ .../predict__a549_mantis_mock.yml | 63 ++ .../predict__a549_mantis_zikv.yml | 63 ++ .../predict__ipsc_confocal.yml | 59 ++ .../joint_ipsc_confocal_a549_mantis/train.yml | 150 +++ .../predict__a549_mantis_denv.yml | 45 + .../predict__a549_mantis_mock.yml | 45 + .../predict__a549_mantis_zikv.yml | 45 + .../ipsc_confocal/predict__ipsc_confocal.yml | 43 + .../ipsc_confocal/train.yml | 61 ++ .../predict__a549_mantis_denv.yml | 2 +- .../predict__a549_mantis_mock.yml | 2 +- .../predict__a549_mantis_zikv.yml | 2 +- .../predict__ipsc_confocal.yml | 2 +- .../a549_mantis/predict__a549_mantis_denv.yml | 12 +- .../predict__a549_mantis_denv_lite.yml | 39 + .../a549_mantis/predict__a549_mantis_mock.yml | 12 +- .../predict__a549_mantis_mock_lite.yml | 39 + .../predict__a549_mantis_movie.yml | 47 + .../a549_mantis/predict__a549_mantis_zikv.yml | 12 +- .../predict__a549_mantis_zikv_lite.yml | 39 + .../predict__hek_mantis_kras_a549xy.yml | 48 + .../a549_mantis/predict__ipsc_confocal.yml | 12 +- .../predict__ipsc_confocal_lite.yml | 37 + .../a549_mantis/train.yml | 8 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 19 - .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 39 + .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 39 + .../predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 39 + .../predict__hek_mantis_kras_a549xy.yml | 48 + .../ipsc_confocal/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../ipsc_confocal/train.yml | 8 +- .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_zikv.yml | 6 +- .../predict__hek_mantis_kras_a549xy.yml | 48 + .../predict__ipsc_confocal.yml | 6 +- .../joint_ipsc_confocal_a549_mantis/train.yml | 10 +- .../a549_mantis/predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 39 + .../a549_mantis/predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 39 + .../a549_mantis/predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 39 + .../a549_mantis/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../a549_mantis/train.yml | 8 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 19 - .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 39 + .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 39 + .../predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 39 + .../ipsc_confocal/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../ipsc_confocal/train.yml | 8 +- .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_zikv.yml | 6 +- .../predict__ipsc_confocal.yml | 6 +- .../joint_ipsc_confocal_a549_mantis/train.yml | 10 +- .../a549_mantis/predict__a549_mantis_denv.yml | 55 + .../a549_mantis/predict__a549_mantis_mock.yml | 55 + .../a549_mantis/predict__a549_mantis_zikv.yml | 55 + .../a549_mantis/predict__ipsc_confocal.yml | 52 + .../membrane/fnet2d/a549_mantis/train.yml | 84 ++ .../predict__a549_mantis_denv.yml | 55 + .../predict__a549_mantis_mock.yml | 55 + .../predict__a549_mantis_zikv.yml | 55 + .../ipsc_confocal/predict__ipsc_confocal.yml | 52 + .../membrane/fnet2d/ipsc_confocal/train.yml | 96 ++ .../predict__a549_mantis_denv.yml | 55 + .../predict__a549_mantis_mock.yml | 55 + .../predict__a549_mantis_zikv.yml | 55 + .../predict__ipsc_confocal.yml | 52 + .../joint_ipsc_confocal_a549_mantis/train.yml | 123 +++ .../predict__a549_mantis_denv.yml | 45 + .../predict__a549_mantis_mock.yml | 45 + .../predict__a549_mantis_zikv.yml | 45 + .../ipsc_confocal/predict__ipsc_confocal.yml | 43 + .../fnet2d_seed1/ipsc_confocal/train.yml | 86 ++ .../a549_mantis/predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 39 + .../a549_mantis/predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 39 + .../a549_mantis/predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 39 + .../predict__hek_mantis_kras_a549xy.yml | 48 + .../a549_mantis/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../fnet3d_paper/a549_mantis/train.yml | 8 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 19 - .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 39 + .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 39 + .../predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 39 + .../predict__hek_mantis_kras_a549xy.yml | 48 + .../ipsc_confocal/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../fnet3d_paper/ipsc_confocal/train.yml | 8 +- .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_zikv.yml | 6 +- .../predict__hek_mantis_kras_a549xy.yml | 48 + .../predict__ipsc_confocal.yml | 6 +- .../joint_ipsc_confocal_a549_mantis/train.yml | 8 +- .../a549_mantis/predict__a549_mantis_denv.yml | 72 ++ .../a549_mantis/predict__a549_mantis_mock.yml | 72 ++ .../a549_mantis/predict__a549_mantis_zikv.yml | 72 ++ .../a549_mantis/predict__ipsc_confocal.yml | 68 ++ .../pix2pix2d_unetvit/a549_mantis/train.yml | 102 ++ .../predict__a549_mantis_denv.yml | 72 ++ .../predict__a549_mantis_mock.yml | 72 ++ .../predict__a549_mantis_zikv.yml | 72 ++ .../ipsc_confocal/predict__ipsc_confocal.yml | 68 ++ .../pix2pix2d_unetvit/ipsc_confocal/train.yml | 102 ++ .../predict__a549_mantis_denv.yml | 72 ++ .../predict__a549_mantis_mock.yml | 72 ++ .../predict__a549_mantis_zikv.yml | 72 ++ .../predict__ipsc_confocal.yml | 68 ++ .../joint_ipsc_confocal_a549_mantis/train.yml | 170 ++++ .../predict__a549_mantis_denv.yml | 45 + .../predict__a549_mantis_mock.yml | 45 + .../predict__a549_mantis_zikv.yml | 45 + .../ipsc_confocal/predict__ipsc_confocal.yml | 43 + .../ipsc_confocal/train.yml | 65 ++ .../a549_mantis/predict__a549_mantis_denv.yml | 44 + .../a549_mantis/predict__a549_mantis_mock.yml | 44 + .../a549_mantis/predict__a549_mantis_zikv.yml | 44 + .../a549_mantis/predict__ipsc_confocal.yml | 42 + .../a549_mantis/train.yml | 69 ++ .../predict__a549_mantis_denv.yml | 44 + .../predict__a549_mantis_mock.yml | 44 + .../predict__a549_mantis_zikv.yml | 44 + .../ipsc_confocal/predict__ipsc_confocal.yml | 42 + .../ipsc_confocal/train.yml | 69 ++ .../predict__a549_mantis_denv.yml | 44 + .../predict__a549_mantis_mock.yml | 44 + .../predict__a549_mantis_zikv.yml | 44 + .../predict__ipsc_confocal.yml | 42 + .../joint_ipsc_confocal_a549_mantis/train.yml | 207 ++++ .../predict__a549_mantis_denv.yml | 44 + .../predict__a549_mantis_mock.yml | 44 + .../predict__a549_mantis_zikv.yml | 44 + .../ipsc_confocal/predict__ipsc_confocal.yml | 42 + .../ipsc_confocal/train.yml | 71 ++ .../a549_mantis/predict__a549_mantis_denv.yml | 11 +- .../a549_mantis/predict__a549_mantis_mock.yml | 11 +- .../a549_mantis/predict__a549_mantis_zikv.yml | 11 +- .../predict__hek_mantis_kras_a549xy.yml | 49 + .../a549_mantis/predict__ipsc_confocal.yml | 11 +- .../pix2pix3d_unetvit/a549_mantis/train.yml | 2 + .../a549_mantis/train_4gpu_modernized.yml | 8 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 13 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 13 - .../predict__a549_mantis_denv.yml | 11 +- .../predict__a549_mantis_mock.yml | 11 +- .../predict__a549_mantis_zikv.yml | 11 +- .../predict__hek_mantis_kras_a549xy.yml | 49 + .../ipsc_confocal/predict__ipsc_confocal.yml | 11 +- .../pix2pix3d_unetvit/ipsc_confocal/train.yml | 2 + .../ipsc_confocal/train_4gpu_modernized.yml | 8 +- .../predict__a549_mantis_denv.yml | 15 +- .../predict__a549_mantis_mock.yml | 15 +- .../predict__a549_mantis_zikv.yml | 15 +- .../predict__hek_mantis_kras_a549xy.yml | 49 + .../predict__ipsc_confocal.yml | 11 +- .../joint_ipsc_confocal_a549_mantis/train.yml | 8 +- .../train_4gpu_modernized.yml | 8 +- .../membrane/unetvit3d/a549_mantis/train.yml | 2 + .../ipsc_confocal/eval__a549_mantis_denv.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 19 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 13 - .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 39 + .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 39 + .../predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 39 + .../ipsc_confocal/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../unetvit3d/ipsc_confocal/train.yml | 2 + .../joint_ipsc_confocal_a549_mantis/train.yml | 2 + .../a549_mantis/predict__a549_mantis_denv.yml | 8 +- .../predict__a549_mantis_denv_lite.yml | 36 + .../a549_mantis/predict__a549_mantis_mock.yml | 8 +- .../predict__a549_mantis_mock_lite.yml | 36 + .../a549_mantis/predict__a549_mantis_zikv.yml | 8 +- .../predict__a549_mantis_zikv_lite.yml | 36 + .../predict__hek_mantis_tomm70a_a549xy.yml | 54 + .../a549_mantis/predict__ipsc_confocal.yml | 8 +- .../predict__ipsc_confocal_lite.yml | 36 + .../mito/celldiff/a549_mantis/train.yml | 8 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 13 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 13 - .../predict__a549_mantis_denv.yml | 8 +- .../predict__a549_mantis_denv_lite.yml | 36 + .../predict__a549_mantis_mock.yml | 8 +- .../predict__a549_mantis_mock_lite.yml | 36 + .../predict__a549_mantis_zikv.yml | 8 +- .../predict__a549_mantis_zikv_lite.yml | 36 + .../predict__hek_mantis_tomm70a_a549xy.yml | 54 + .../predict__ipsc_confocal__denoise.yml | 8 +- .../predict__ipsc_confocal__iterative.yml | 8 +- ...predict__ipsc_confocal__iterative_lite.yml | 36 + ...predict__ipsc_confocal__sliding_window.yml | 8 +- .../mito/celldiff/ipsc_confocal/train.yml | 6 +- .../predict__a549_mantis_denv.yml | 8 +- .../predict__a549_mantis_denv_lite.yml | 36 + .../predict__a549_mantis_mock.yml | 8 +- .../predict__a549_mantis_mock_lite.yml | 36 + .../predict__a549_mantis_zikv.yml | 8 +- .../predict__a549_mantis_zikv_lite.yml | 36 + .../predict__hek_mantis_tomm70a_a549xy.yml | 54 + .../predict__ipsc_confocal.yml | 8 +- .../predict__ipsc_confocal_lite.yml | 36 + .../joint_ipsc_confocal_a549_mantis/train.yml | 8 +- .../a549_mantis/predict__a549_mantis_denv.yml | 55 + .../a549_mantis/predict__a549_mantis_mock.yml | 55 + .../a549_mantis/predict__a549_mantis_zikv.yml | 55 + .../a549_mantis/predict__ipsc_confocal.yml | 55 + .../mito/celldiff_2d/a549_mantis/train.yml | 82 ++ .../predict__a549_mantis_denv.yml | 55 + .../predict__a549_mantis_mock.yml | 55 + .../predict__a549_mantis_zikv.yml | 55 + .../ipsc_confocal/predict__ipsc_confocal.yml | 55 + .../mito/celldiff_2d/ipsc_confocal/train.yml | 82 ++ .../predict__a549_mantis_denv.yml | 55 + .../predict__a549_mantis_mock.yml | 55 + .../predict__a549_mantis_zikv.yml | 55 + .../predict__ipsc_confocal.yml | 55 + .../joint_ipsc_confocal_a549_mantis/train.yml | 138 +++ .../a549_mantis/predict__a549_mantis_denv.yml | 59 ++ .../a549_mantis/predict__a549_mantis_mock.yml | 59 ++ .../a549_mantis/predict__a549_mantis_zikv.yml | 59 ++ .../a549_mantis/predict__ipsc_confocal.yml | 59 ++ .../a549_mantis/train.yml | 73 ++ .../predict__a549_mantis_denv.yml | 59 ++ .../predict__a549_mantis_mock.yml | 59 ++ .../predict__a549_mantis_zikv.yml | 59 ++ .../ipsc_confocal/predict__ipsc_confocal.yml | 59 ++ .../ipsc_confocal/train.yml | 83 ++ .../predict__a549_mantis_denv.yml | 59 ++ .../predict__a549_mantis_mock.yml | 59 ++ .../predict__a549_mantis_zikv.yml | 59 ++ .../predict__ipsc_confocal.yml | 59 ++ .../joint_ipsc_confocal_a549_mantis/train.yml | 165 +++ .../a549_mantis/predict__a549_mantis_denv.yml | 59 ++ .../a549_mantis/predict__a549_mantis_mock.yml | 59 ++ .../a549_mantis/predict__a549_mantis_zikv.yml | 59 ++ .../a549_mantis/predict__ipsc_confocal.yml | 59 ++ .../a549_mantis/train.yml | 64 ++ .../predict__a549_mantis_denv.yml | 59 ++ .../predict__a549_mantis_mock.yml | 59 ++ .../predict__a549_mantis_zikv.yml | 59 ++ .../ipsc_confocal/predict__ipsc_confocal.yml | 59 ++ .../ipsc_confocal/train.yml | 72 ++ .../predict__a549_mantis_denv.yml | 59 ++ .../predict__a549_mantis_mock.yml | 59 ++ .../predict__a549_mantis_zikv.yml | 59 ++ .../predict__ipsc_confocal.yml | 59 ++ .../joint_ipsc_confocal_a549_mantis/train.yml | 150 +++ .../predict__a549_mantis_denv.yml | 2 +- .../predict__a549_mantis_mock.yml | 2 +- .../predict__a549_mantis_zikv.yml | 2 +- .../predict__ipsc_confocal.yml | 2 +- .../a549_mantis/predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 37 + .../a549_mantis/predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 37 + .../a549_mantis/predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 37 + .../predict__hek_mantis_tomm70a_a549xy.yml | 48 + .../a549_mantis/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../a549_mantis/train.yml | 10 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 13 - .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 37 + .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 37 + .../predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 37 + .../predict__hek_mantis_tomm70a_a549xy.yml | 48 + .../ipsc_confocal/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../ipsc_confocal/train.yml | 8 +- .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_zikv.yml | 6 +- .../predict__hek_mantis_tomm70a_a549xy.yml | 48 + .../predict__ipsc_confocal.yml | 6 +- .../joint_ipsc_confocal_a549_mantis/train.yml | 12 +- .../a549_mantis/predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 37 + .../a549_mantis/predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 37 + .../a549_mantis/predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 37 + .../a549_mantis/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../a549_mantis/train.yml | 10 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 13 - .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 37 + .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 37 + .../predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 37 + .../ipsc_confocal/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../ipsc_confocal/train.yml | 8 +- .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_zikv.yml | 6 +- .../predict__ipsc_confocal.yml | 6 +- .../joint_ipsc_confocal_a549_mantis/train.yml | 12 +- .../a549_mantis/predict__a549_mantis_denv.yml | 52 + .../a549_mantis/predict__a549_mantis_mock.yml | 52 + .../a549_mantis/predict__a549_mantis_zikv.yml | 52 + .../a549_mantis/predict__ipsc_confocal.yml | 52 + .../mito/fnet2d/a549_mantis/train.yml | 56 ++ .../predict__a549_mantis_denv.yml | 52 + .../predict__a549_mantis_mock.yml | 52 + .../predict__a549_mantis_zikv.yml | 52 + .../ipsc_confocal/predict__ipsc_confocal.yml | 52 + .../mito/fnet2d/ipsc_confocal/train.yml | 63 ++ .../predict__a549_mantis_denv.yml | 52 + .../predict__a549_mantis_mock.yml | 52 + .../predict__a549_mantis_zikv.yml | 52 + .../predict__ipsc_confocal.yml | 52 + .../joint_ipsc_confocal_a549_mantis/train.yml | 123 +++ .../a549_mantis/predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 37 + .../a549_mantis/predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 37 + .../a549_mantis/predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 37 + .../predict__hek_mantis_tomm70a_a549xy.yml | 48 + .../a549_mantis/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../mito/fnet3d_paper/a549_mantis/train.yml | 10 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 13 - .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 37 + .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 37 + .../predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 37 + .../predict__hek_mantis_tomm70a_a549xy.yml | 48 + .../ipsc_confocal/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../mito/fnet3d_paper/ipsc_confocal/train.yml | 8 +- .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_zikv.yml | 6 +- .../predict__hek_mantis_tomm70a_a549xy.yml | 48 + .../predict__ipsc_confocal.yml | 6 +- .../joint_ipsc_confocal_a549_mantis/train.yml | 10 +- .../a549_mantis/predict__a549_mantis_denv.yml | 68 ++ .../a549_mantis/predict__a549_mantis_mock.yml | 68 ++ .../a549_mantis/predict__a549_mantis_zikv.yml | 68 ++ .../a549_mantis/predict__ipsc_confocal.yml | 68 ++ .../pix2pix2d_unetvit/a549_mantis/train.yml | 102 ++ .../predict__a549_mantis_denv.yml | 68 ++ .../predict__a549_mantis_mock.yml | 68 ++ .../predict__a549_mantis_zikv.yml | 68 ++ .../ipsc_confocal/predict__ipsc_confocal.yml | 68 ++ .../pix2pix2d_unetvit/ipsc_confocal/train.yml | 102 ++ .../predict__a549_mantis_denv.yml | 68 ++ .../predict__a549_mantis_mock.yml | 68 ++ .../predict__a549_mantis_zikv.yml | 68 ++ .../predict__ipsc_confocal.yml | 68 ++ .../joint_ipsc_confocal_a549_mantis/train.yml | 170 ++++ .../a549_mantis/predict__a549_mantis_denv.yml | 42 + .../a549_mantis/predict__a549_mantis_mock.yml | 42 + .../a549_mantis/predict__a549_mantis_zikv.yml | 42 + .../a549_mantis/predict__ipsc_confocal.yml | 42 + .../a549_mantis/train.yml | 69 ++ .../predict__a549_mantis_denv.yml | 42 + .../predict__a549_mantis_mock.yml | 42 + .../predict__a549_mantis_zikv.yml | 42 + .../ipsc_confocal/predict__ipsc_confocal.yml | 42 + .../ipsc_confocal/train.yml | 69 ++ .../predict__a549_mantis_denv.yml | 42 + .../predict__a549_mantis_mock.yml | 42 + .../predict__a549_mantis_zikv.yml | 42 + .../predict__ipsc_confocal.yml | 42 + .../joint_ipsc_confocal_a549_mantis/train.yml | 207 ++++ .../a549_mantis/predict__a549_mantis_denv.yml | 48 + .../a549_mantis/predict__a549_mantis_mock.yml | 48 + .../a549_mantis/predict__a549_mantis_zikv.yml | 48 + .../predict__hek_mantis_tomm70a_a549xy.yml | 49 + .../a549_mantis/predict__ipsc_confocal.yml | 48 + .../pix2pix3d_unetvit/a549_mantis/train.yml | 2 + .../a549_mantis/train_4gpu_modernized.yml | 59 ++ .../ipsc_confocal/eval__a549_mantis_denv.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 13 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 13 - .../predict__a549_mantis_denv.yml | 11 +- .../predict__a549_mantis_mock.yml | 11 +- .../predict__a549_mantis_zikv.yml | 11 +- .../predict__hek_mantis_tomm70a_a549xy.yml | 49 + .../ipsc_confocal/predict__ipsc_confocal.yml | 11 +- .../pix2pix3d_unetvit/ipsc_confocal/train.yml | 2 + .../ipsc_confocal/train_4gpu_modernized.yml | 69 ++ .../predict__a549_mantis_denv.yml | 11 +- .../predict__a549_mantis_mock.yml | 11 +- .../predict__a549_mantis_zikv.yml | 11 +- .../predict__hek_mantis_tomm70a_a549xy.yml | 49 + .../predict__ipsc_confocal.yml | 11 +- .../joint_ipsc_confocal_a549_mantis/train.yml | 2 + .../train_4gpu_modernized.yml | 159 +++ .../a549_mantis/predict__a549_mantis_denv.yml | 43 + .../predict__a549_mantis_denv_lite.yml | 37 + .../a549_mantis/predict__a549_mantis_mock.yml | 43 + .../predict__a549_mantis_mock_lite.yml | 37 + .../a549_mantis/predict__a549_mantis_zikv.yml | 43 + .../predict__a549_mantis_zikv_lite.yml | 37 + .../a549_mantis/predict__ipsc_confocal.yml | 43 + .../predict__ipsc_confocal_lite.yml | 37 + .../mito/unetvit3d/a549_mantis/train.yml | 10 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 13 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 13 - .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 37 + .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 37 + .../predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 37 + .../ipsc_confocal/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../mito/unetvit3d/ipsc_confocal/train.yml | 8 +- .../predict__a549_mantis_denv.yml | 43 + .../predict__a549_mantis_mock.yml | 43 + .../predict__a549_mantis_zikv.yml | 43 + .../predict__ipsc_confocal.yml | 43 + .../joint_ipsc_confocal_a549_mantis/train.yml | 15 +- .../a549_mantis/predict__a549_mantis_denv.yml | 8 +- .../predict__a549_mantis_denv_lite.yml | 38 + .../a549_mantis/predict__a549_mantis_mock.yml | 8 +- .../predict__a549_mantis_mock_lite.yml | 38 + .../predict__a549_mantis_movie.yml | 47 + .../a549_mantis/predict__a549_mantis_zikv.yml | 8 +- .../predict__a549_mantis_zikv_lite.yml | 38 + .../a549_mantis/predict__ipsc_confocal.yml | 8 +- .../predict__ipsc_confocal_lite.yml | 36 + .../nucleus/celldiff/a549_mantis/train.yml | 6 +- .../predict__a549_mantis_denv.yml | 59 ++ .../predict__a549_mantis_mock.yml | 59 ++ .../predict__a549_mantis_zikv.yml | 59 ++ .../predict__ipsc_confocal__iterative.yml | 55 + .../a549_mantis_brightfield/train.yml | 68 ++ .../ipsc_confocal/eval__a549_mantis_denv.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 19 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 13 - .../predict__a549_mantis_denv.yml | 8 +- .../predict__a549_mantis_denv_lite.yml | 38 + .../predict__a549_mantis_mock.yml | 8 +- .../predict__a549_mantis_mock_lite.yml | 38 + .../predict__a549_mantis_zikv.yml | 8 +- .../predict__a549_mantis_zikv_lite.yml | 38 + .../predict__ipsc_confocal__denoise.yml | 8 +- .../predict__ipsc_confocal__iterative.yml | 8 +- ...predict__ipsc_confocal__iterative_lite.yml | 36 + ...predict__ipsc_confocal__sliding_window.yml | 8 +- .../nucleus/celldiff/ipsc_confocal/train.yml | 6 +- .../predict__a549_mantis_denv.yml | 59 ++ .../predict__a549_mantis_mock.yml | 59 ++ .../predict__a549_mantis_zikv.yml | 59 ++ .../predict__ipsc_confocal__iterative.yml | 55 + .../ipsc_confocal_brightfield/train.yml | 65 ++ .../predict__a549_mantis_denv.yml | 8 +- .../predict__a549_mantis_denv_lite.yml | 38 + .../predict__a549_mantis_mock.yml | 8 +- .../predict__a549_mantis_mock_lite.yml | 38 + .../predict__a549_mantis_zikv.yml | 8 +- .../predict__a549_mantis_zikv_lite.yml | 38 + .../predict__ipsc_confocal.yml | 8 +- .../predict__ipsc_confocal_lite.yml | 36 + .../joint_ipsc_confocal_a549_mantis/train.yml | 6 +- .../a549_mantis/predict__a549_mantis_denv.yml | 59 ++ .../a549_mantis/predict__a549_mantis_mock.yml | 59 ++ .../a549_mantis/predict__a549_mantis_zikv.yml | 59 ++ .../a549_mantis/predict__ipsc_confocal.yml | 55 + .../nucleus/celldiff_2d/a549_mantis/train.yml | 82 ++ .../predict__a549_mantis_denv.yml | 59 ++ .../predict__a549_mantis_mock.yml | 59 ++ .../predict__a549_mantis_zikv.yml | 59 ++ .../ipsc_confocal/predict__ipsc_confocal.yml | 55 + .../celldiff_2d/ipsc_confocal/train.yml | 82 ++ .../celldiff_2d/ipsc_confocal/train_smoke.yml | 67 ++ .../predict__a549_mantis_denv.yml | 59 ++ .../predict__a549_mantis_mock.yml | 59 ++ .../predict__a549_mantis_zikv.yml | 59 ++ .../predict__ipsc_confocal.yml | 55 + .../joint_ipsc_confocal_a549_mantis/train.yml | 138 +++ .../predict__a549_mantis_denv.yml | 43 + .../predict__a549_mantis_mock.yml | 43 + .../predict__a549_mantis_zikv.yml | 43 + .../ipsc_confocal/predict__ipsc_confocal.yml | 41 + .../celldiff_2d_seed1/ipsc_confocal/train.yml | 61 ++ .../a549_mantis/predict__a549_mantis_denv.yml | 63 ++ .../a549_mantis/predict__a549_mantis_mock.yml | 63 ++ .../a549_mantis/predict__a549_mantis_zikv.yml | 63 ++ .../a549_mantis/predict__ipsc_confocal.yml | 59 ++ .../a549_mantis/train.yml | 85 ++ .../predict__a549_mantis_denv.yml | 63 ++ .../predict__a549_mantis_mock.yml | 63 ++ .../predict__a549_mantis_zikv.yml | 63 ++ .../ipsc_confocal/predict__ipsc_confocal.yml | 59 ++ .../ipsc_confocal/train.yml | 93 ++ .../predict__a549_mantis_denv.yml | 63 ++ .../predict__a549_mantis_mock.yml | 63 ++ .../predict__a549_mantis_zikv.yml | 63 ++ .../predict__ipsc_confocal.yml | 59 ++ .../joint_ipsc_confocal_a549_mantis/train.yml | 165 +++ .../a549_mantis/predict__a549_mantis_denv.yml | 63 ++ .../a549_mantis/predict__a549_mantis_mock.yml | 63 ++ .../a549_mantis/predict__a549_mantis_zikv.yml | 63 ++ .../a549_mantis/predict__ipsc_confocal.yml | 59 ++ .../a549_mantis/train.yml | 75 ++ .../predict__a549_mantis_denv.yml | 63 ++ .../predict__a549_mantis_mock.yml | 63 ++ .../predict__a549_mantis_zikv.yml | 63 ++ .../ipsc_confocal/predict__ipsc_confocal.yml | 59 ++ .../ipsc_confocal/train.yml | 83 ++ .../predict__a549_mantis_denv.yml | 63 ++ .../predict__a549_mantis_mock.yml | 63 ++ .../predict__a549_mantis_zikv.yml | 63 ++ .../predict__ipsc_confocal.yml | 59 ++ .../joint_ipsc_confocal_a549_mantis/train.yml | 150 +++ .../predict__a549_mantis_denv.yml | 65 ++ .../predict__a549_mantis_mock.yml | 65 ++ .../predict__a549_mantis_zikv.yml | 65 ++ .../ipsc_confocal/predict__ipsc_confocal.yml | 61 ++ .../ipsc_confocal/train.yml | 108 ++ .../predict__a549_mantis_denv.yml | 45 + .../predict__a549_mantis_mock.yml | 45 + .../predict__a549_mantis_zikv.yml | 45 + .../ipsc_confocal/predict__ipsc_confocal.yml | 43 + .../ipsc_confocal/train.yml | 61 ++ .../predict__a549_mantis_denv.yml | 2 +- .../predict__a549_mantis_mock.yml | 2 +- .../predict__a549_mantis_zikv.yml | 2 +- .../predict__ipsc_confocal.yml | 2 +- .../a549_mantis/predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 39 + .../a549_mantis/predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 39 + .../predict__a549_mantis_movie.yml | 47 + .../a549_mantis/predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 39 + .../a549_mantis/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../a549_mantis/train.yml | 8 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 19 - .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 39 + .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 39 + .../predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 39 + .../ipsc_confocal/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../ipsc_confocal/train.yml | 8 +- .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_zikv.yml | 6 +- .../predict__ipsc_confocal.yml | 6 +- .../joint_ipsc_confocal_a549_mantis/train.yml | 10 +- .../a549_mantis/predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 39 + .../a549_mantis/predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 39 + .../a549_mantis/predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 39 + .../a549_mantis/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../a549_mantis/train.yml | 8 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 19 - .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 39 + .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 39 + .../predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 39 + .../ipsc_confocal/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../ipsc_confocal/train.yml | 8 +- .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_zikv.yml | 6 +- .../predict__ipsc_confocal.yml | 6 +- .../joint_ipsc_confocal_a549_mantis/train.yml | 10 +- .../a549_mantis/predict__a549_mantis_denv.yml | 55 + .../a549_mantis/predict__a549_mantis_mock.yml | 55 + .../a549_mantis/predict__a549_mantis_zikv.yml | 55 + .../a549_mantis/predict__ipsc_confocal.yml | 52 + .../nucleus/fnet2d/a549_mantis/train.yml | 85 ++ .../predict__a549_mantis_denv.yml | 55 + .../predict__a549_mantis_mock.yml | 55 + .../predict__a549_mantis_zikv.yml | 55 + .../ipsc_confocal/predict__ipsc_confocal.yml | 52 + .../nucleus/fnet2d/ipsc_confocal/train.yml | 96 ++ .../predict__a549_mantis_denv.yml | 55 + .../predict__a549_mantis_mock.yml | 55 + .../predict__a549_mantis_zikv.yml | 55 + .../predict__ipsc_confocal.yml | 52 + .../joint_ipsc_confocal_a549_mantis/train.yml | 126 +++ .../predict__a549_mantis_denv.yml | 45 + .../predict__a549_mantis_mock.yml | 45 + .../predict__a549_mantis_zikv.yml | 45 + .../ipsc_confocal/predict__ipsc_confocal.yml | 43 + .../fnet2d_seed1/ipsc_confocal/train.yml | 86 ++ .../predict__a549_mantis_denv.yml | 55 + .../predict__a549_mantis_mock.yml | 55 + .../predict__a549_mantis_zikv.yml | 55 + .../ipsc_confocal/predict__ipsc_confocal.yml | 52 + .../ipsc_confocal/train.yml | 97 ++ .../predict__a549_mantis_h2b_denv.yml | 53 + .../predict__a549_mantis_h2b_mock.yml | 53 + .../predict__a549_mantis_h2b_zikv.yml | 53 + .../ipsc_confocal/predict__ipsc_confocal.yml | 48 + .../fnet3d_bigpatch/ipsc_confocal/train.yml | 83 ++ .../predict__a549_mantis_denv.yml | 66 ++ .../predict__a549_mantis_mock.yml | 66 ++ .../predict__a549_mantis_zikv.yml | 66 ++ .../predict__ipsc_confocal.yml | 62 ++ .../ipsc_confocal_brightfield/train.yml | 95 ++ .../a549_mantis/predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 39 + .../a549_mantis/predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 39 + .../a549_mantis/predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 39 + .../a549_mantis/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../fnet3d_paper/a549_mantis/train.yml | 8 +- .../predict__a549_mantis_denv.yml | 60 ++ .../predict__a549_mantis_mock.yml | 60 ++ .../predict__a549_mantis_zikv.yml | 60 ++ .../predict__ipsc_confocal.yml | 56 ++ .../a549_mantis_brightfield/train.yml | 85 ++ .../ipsc_confocal/eval__a549_mantis_denv.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 19 - .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 39 + .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 39 + .../predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 39 + .../ipsc_confocal/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../fnet3d_paper/ipsc_confocal/train.yml | 8 +- .../predict__a549_mantis_denv.yml | 60 ++ .../predict__a549_mantis_mock.yml | 60 ++ .../predict__a549_mantis_zikv.yml | 60 ++ .../predict__ipsc_confocal.yml | 56 ++ .../ipsc_confocal_brightfield/train.yml | 83 ++ .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_zikv.yml | 6 +- .../predict__ipsc_confocal.yml | 6 +- .../joint_ipsc_confocal_a549_mantis/train.yml | 8 +- .../predict__a549_mantis_h2b_denv.yml | 60 ++ .../predict__a549_mantis_h2b_mock.yml | 60 ++ .../predict__a549_mantis_h2b_zikv.yml | 60 ++ .../nucleus/fnet3d_t01/a549_mantis/train.yml | 106 ++ .../fnet3d_t01/a549_mantis/train_smoke.yml | 70 ++ .../predict__a549_mantis_h2b_denv.yml | 60 ++ .../predict__a549_mantis_h2b_mock.yml | 60 ++ .../predict__a549_mantis_h2b_zikv.yml | 60 ++ .../fnet3d_tspread/a549_mantis/train.yml | 107 ++ .../predict__a549_mantis_h2b_denv.yml | 54 + .../predict__a549_mantis_h2b_mock.yml | 54 + .../predict__a549_mantis_h2b_zikv.yml | 54 + .../ipsc_confocal/predict__ipsc_confocal.yml | 49 + .../ipsc_confocal/train.yml | 86 ++ .../ipsc_confocal/train_smoke.yml | 66 ++ .../predict__a549_mantis_denv.yml | 66 ++ .../predict__a549_mantis_mock.yml | 66 ++ .../predict__a549_mantis_zikv.yml | 66 ++ .../predict__ipsc_confocal.yml | 62 ++ .../ipsc_confocal_brightfield/train.yml | 103 ++ .../a549_mantis/predict__a549_mantis_denv.yml | 72 ++ .../a549_mantis/predict__a549_mantis_mock.yml | 72 ++ .../a549_mantis/predict__a549_mantis_zikv.yml | 72 ++ .../a549_mantis/predict__ipsc_confocal.yml | 68 ++ .../pix2pix2d_unetvit/a549_mantis/train.yml | 102 ++ .../predict__a549_mantis_denv.yml | 72 ++ .../predict__a549_mantis_mock.yml | 72 ++ .../predict__a549_mantis_zikv.yml | 72 ++ .../ipsc_confocal/predict__ipsc_confocal.yml | 68 ++ .../pix2pix2d_unetvit/ipsc_confocal/train.yml | 102 ++ .../predict__a549_mantis_denv.yml | 72 ++ .../predict__a549_mantis_mock.yml | 72 ++ .../predict__a549_mantis_zikv.yml | 72 ++ .../predict__ipsc_confocal.yml | 68 ++ .../joint_ipsc_confocal_a549_mantis/train.yml | 170 ++++ .../predict__a549_mantis_denv.yml | 45 + .../predict__a549_mantis_mock.yml | 45 + .../predict__a549_mantis_zikv.yml | 45 + .../ipsc_confocal/predict__ipsc_confocal.yml | 43 + .../ipsc_confocal/train.yml | 65 ++ .../a549_mantis/predict__a549_mantis_denv.yml | 44 + .../a549_mantis/predict__a549_mantis_mock.yml | 44 + .../a549_mantis/predict__a549_mantis_zikv.yml | 44 + .../a549_mantis/predict__ipsc_confocal.yml | 42 + .../a549_mantis/train.yml | 69 ++ .../predict__a549_mantis_denv.yml | 44 + .../predict__a549_mantis_mock.yml | 44 + .../predict__a549_mantis_zikv.yml | 44 + .../ipsc_confocal/predict__ipsc_confocal.yml | 42 + .../ipsc_confocal/train.yml | 69 ++ .../predict__a549_mantis_denv.yml | 44 + .../predict__a549_mantis_mock.yml | 44 + .../predict__a549_mantis_zikv.yml | 44 + .../predict__ipsc_confocal.yml | 42 + .../joint_ipsc_confocal_a549_mantis/train.yml | 207 ++++ .../predict__a549_mantis_denv.yml | 44 + .../predict__a549_mantis_mock.yml | 44 + .../predict__a549_mantis_zikv.yml | 44 + .../ipsc_confocal/predict__ipsc_confocal.yml | 42 + .../ipsc_confocal/train.yml | 71 ++ .../a549_mantis/predict__a549_mantis_denv.yml | 11 +- .../a549_mantis/predict__a549_mantis_mock.yml | 11 +- .../a549_mantis/predict__a549_mantis_zikv.yml | 11 +- .../a549_mantis/predict__ipsc_confocal.yml | 11 +- .../pix2pix3d_unetvit/a549_mantis/train.yml | 2 + .../a549_mantis/train_4gpu_modernized.yml | 8 +- .../ipsc_confocal/eval__a549_mantis_denv.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 13 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 13 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 13 - .../predict__a549_mantis_denv.yml | 17 +- .../predict__a549_mantis_mock.yml | 17 +- .../predict__a549_mantis_zikv.yml | 17 +- .../ipsc_confocal/predict__ipsc_confocal.yml | 17 +- .../pix2pix3d_unetvit/ipsc_confocal/train.yml | 2 + .../ipsc_confocal/train_4gpu_modernized.yml | 8 +- .../predict__a549_mantis_denv.yml | 11 +- .../predict__a549_mantis_mock.yml | 11 +- .../predict__a549_mantis_zikv.yml | 11 +- .../predict__ipsc_confocal.yml | 11 +- .../joint_ipsc_confocal_a549_mantis/train.yml | 2 + .../train_4gpu_modernized.yml | 8 +- .../nucleus/unetvit3d/a549_mantis/train.yml | 2 + .../ipsc_confocal/eval__a549_mantis_denv.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_mock.yaml | 19 - .../ipsc_confocal/eval__a549_mantis_zikv.yaml | 19 - .../ipsc_confocal/eval__ipsc_confocal.yaml | 13 - .../predict__a549_mantis_denv.yml | 6 +- .../predict__a549_mantis_denv_lite.yml | 39 + .../predict__a549_mantis_mock.yml | 6 +- .../predict__a549_mantis_mock_lite.yml | 39 + .../predict__a549_mantis_zikv.yml | 6 +- .../predict__a549_mantis_zikv_lite.yml | 39 + .../ipsc_confocal/predict__ipsc_confocal.yml | 6 +- .../predict__ipsc_confocal_lite.yml | 37 + .../nucleus/unetvit3d/ipsc_confocal/train.yml | 8 +- .../joint_ipsc_confocal_a549_mantis/train.yml | 2 + .../virtual_staining/membrane_ipsc_v1.yaml | 658 ++++++++++++ .../membrane_joint_all_v1.yaml | 941 ++++++++++++++++++ .../membrane_joint_mock_v1.yaml | 779 +++++++++++++++ .../virtual_staining/nucleus_ipsc_v1.yaml | 658 ++++++++++++ .../nucleus_joint_all_v1.yaml | 941 ++++++++++++++++++ .../nucleus_joint_mock_v1.yaml | 779 +++++++++++++++ .../virtual_staining/sec61b_ipsc_v1.yaml | 587 +++++++++++ .../virtual_staining/sec61b_joint_all_v1.yaml | 806 +++++++++++++++ .../sec61b_joint_mock_v1.yaml | 731 ++++++++++++++ .../virtual_staining/tomm20_joint_all_v1.yaml | 911 +++++++++++++++++ .../tomm20_joint_mock_v1.yaml | 879 ++++++++++++++++ .../configs/recipes/models/celldiff_fm_2d.yml | 32 + .../configs/recipes/models/fnet2d.yml | 23 + .../recipes/models/pix2pix2d_unetvit.yml | 54 + .../configs/recipes/modes/spotlight.yml | 4 + .../configs/recipes/topology/ddp_4gpu_gan.yml | 12 +- .../configs/recipes/trainer/predict.yml | 1 + 1522 files changed, 73138 insertions(+), 4505 deletions(-) create mode 100644 applications/dynacell/configs/README.md create mode 100644 applications/dynacell/configs/benchmarks/README.md create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__hek_mantis_kras_a549xy.yml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/phase/eval__a549_mantis_sec61b_denv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/phase/eval__a549_mantis_sec61b_mock.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/phase/eval__a549_mantis_sec61b_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/phase/eval__ipsc_confocal.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er__2d_focus2d_pix2pix2d_wmatch/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_bf_trained/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__2d_focus2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__2d_focusslab3/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__lite/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__temporal/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_bf_trained/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d_focus2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d_focusslab3/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d_samplematched/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d_voxelmatched/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__lite/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint__2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint__2d_focus2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint__2d_focusslab3/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint__lite/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_phase_floor__2d_focus2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_phase_floor__2d_focusslab3/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane__2d_focus2d_pix2pix2d_wmatch/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained__2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained__2d_focus2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained__lite/eval_grouped.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained_carved/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_hek_a549xy/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_hek_a549xy_celldiff/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_hek_a549xy_pix2pix/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained__2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained__2d_focus2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained__2d_focus2d_seed1/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained__lite/eval_grouped.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained_carved/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint__2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint__2d_focus2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint__lite/eval_grouped.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint_carved/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_phase_floor__2d_focus2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria__2d_focus2d_pix2pix2d_wmatch/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained__2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained__2d_focus2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained__2d_focusslab3/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained__lite/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_hek_a549xy/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_hek_a549xy_celldiff/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_hek_a549xy_pix2pix/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained__2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained__2d_focus2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained__2d_focusslab3/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained__lite/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint__2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint__2d_focus2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint__2d_focusslab3/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint__lite/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_phase_floor__2d_focus2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_phase_floor__2d_focusslab3/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus__2d_focus2d_pix2pix2d_wmatch/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_bf_trained/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained__2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained__2d_focus2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained__lite/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained__temporal/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_bf_trained/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_bf_trained__patchaug/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d_focus2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d_focus2d_seed1/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d_samplematched/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d_voxelmatched/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__lite/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__patchaug/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_joint__2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_joint__2d_focus2d/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_joint__lite/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_phase_floor__2d_focus2d/eval_grouped.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/phase/eval__a549_mantis_caax_denv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/phase/eval__a549_mantis_caax_mock.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/phase/eval__a549_mantis_caax_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/phase/eval__ipsc_confocal.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/phase/eval__a549_mantis_tomm20_denv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/phase/eval__a549_mantis_tomm20_mock.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/phase/eval__a549_mantis_tomm20_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/phase/eval__ipsc_confocal.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/phase/eval__a549_mantis_h2b_denv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/phase/eval__a549_mantis_h2b_mock.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/phase/eval__a549_mantis_h2b_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/phase/eval__ipsc_confocal.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 120000 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_a549_trained__a549_denv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_a549_trained__a549_mock/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_a549_trained__a549_zikv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_a549_trained__ipsc/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_ipsc_trained__a549_denv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_ipsc_trained__a549_mock/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_ipsc_trained__a549_zikv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_ipsc_trained__ipsc/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_joint__a549_denv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_joint__a549_mock/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_joint__a549_zikv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_joint__ipsc/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_a549_trained__a549_denv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_a549_trained__a549_mock/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_a549_trained__a549_zikv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_a549_trained__ipsc/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_ipsc_trained__a549_denv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_ipsc_trained__a549_mock/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_ipsc_trained__a549_zikv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_ipsc_trained__ipsc/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_joint__a549_denv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_joint__a549_mock/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_joint__a549_zikv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_joint__ipsc/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_a549_trained__a549_denv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_a549_trained__a549_mock/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_a549_trained__a549_zikv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_a549_trained__ipsc/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_ipsc_trained__a549_denv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_ipsc_trained__a549_mock/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_ipsc_trained__a549_zikv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_ipsc_trained__ipsc/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_joint__a549_denv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_joint__a549_mock/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_joint__a549_zikv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_joint__ipsc/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_a549_trained__a549_denv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_a549_trained__a549_mock/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_a549_trained__a549_zikv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_a549_trained__ipsc/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_ipsc_trained__a549_denv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_ipsc_trained__a549_mock/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_ipsc_trained__a549_zikv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_ipsc_trained__ipsc/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_joint__a549_denv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_joint__a549_mock/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_joint__a549_zikv/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_joint__ipsc/eval_grouped.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/celldiff_2d_fit.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/fnet2d_fit.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/fnet3d_bigpatch_fit.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/fnet3d_vscyto3daug_fit.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_4gpu_long.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_predict_h200.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/celldiff_2d_fit.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/celldiff_2d_predict.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/celldiff_predict_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fnet2d_fit.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fnet2d_predict.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_caax_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_caax_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_caax_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_h2b_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_h2b_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_h2b_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_sec61b_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_sec61b_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_tomm20_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_tomm20_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/hek_mantis_dual_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/hek_mantis_kras_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/hek_mantis_tomm70a_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/train_sets/a549_mantis_brightfield.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/train_sets/ipsc_confocal_brightfield.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/predict__ipsc_confocal__iterative.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/train.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/predict__ipsc_confocal__iterative.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal_lite.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal_lite.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/train.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/predict__a549_mantis_sec61b_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/predict__a549_mantis_sec61b_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/predict__a549_mantis_sec61b_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/train_smoke.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_tspread/a549_mantis/predict__a549_mantis_sec61b_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_tspread/a549_mantis/predict__a549_mantis_sec61b_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_tspread/a549_mantis/predict__a549_mantis_sec61b_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_tspread/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/eval__ipsc_confocal.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__ipsc_confocal_lite.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_movie.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__hek_mantis_kras_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__ipsc_confocal_lite.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__hek_mantis_kras_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_kras_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_movie.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__hek_mantis_kras_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal_lite.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__hek_mantis_kras_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_kras_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal_lite.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__hek_mantis_kras_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__ipsc_confocal_lite.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__hek_mantis_kras_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_kras_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__hek_mantis_kras_a549xy.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/eval__ipsc_confocal.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__hek_mantis_kras_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_kras_a549xy.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__ipsc_confocal_lite.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__hek_mantis_tomm70a_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal_lite.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__hek_mantis_tomm70a_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal_lite.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__ipsc_confocal_lite.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__hek_mantis_tomm70a_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/eval__ipsc_confocal.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__hek_mantis_tomm70a_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__ipsc_confocal_lite.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_movie.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/predict__ipsc_confocal__iterative.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/train.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/predict__ipsc_confocal__iterative.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/train_smoke.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_movie.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal_lite.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal_lite.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/predict__a549_mantis_h2b_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/predict__a549_mantis_h2b_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/predict__a549_mantis_h2b_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/train.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/predict__a549_mantis_h2b_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/predict__a549_mantis_h2b_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/predict__a549_mantis_h2b_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/train_smoke.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_tspread/a549_mantis/predict__a549_mantis_h2b_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_tspread/a549_mantis/predict__a549_mantis_h2b_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_tspread/a549_mantis/predict__a549_mantis_h2b_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_tspread/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__a549_mantis_h2b_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__a549_mantis_h2b_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__a549_mantis_h2b_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/train_smoke.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/train.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_denv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_mock.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__ipsc_confocal.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/train.yml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/eval__ipsc_confocal.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml delete mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_denv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_mock_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv_lite.yml create mode 100644 applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__ipsc_confocal_lite.yml create mode 100644 applications/dynacell/configs/collections/virtual_staining/membrane_ipsc_v1.yaml create mode 100644 applications/dynacell/configs/collections/virtual_staining/membrane_joint_all_v1.yaml create mode 100644 applications/dynacell/configs/collections/virtual_staining/membrane_joint_mock_v1.yaml create mode 100644 applications/dynacell/configs/collections/virtual_staining/nucleus_ipsc_v1.yaml create mode 100644 applications/dynacell/configs/collections/virtual_staining/nucleus_joint_all_v1.yaml create mode 100644 applications/dynacell/configs/collections/virtual_staining/nucleus_joint_mock_v1.yaml create mode 100644 applications/dynacell/configs/collections/virtual_staining/sec61b_ipsc_v1.yaml create mode 100644 applications/dynacell/configs/collections/virtual_staining/sec61b_joint_all_v1.yaml create mode 100644 applications/dynacell/configs/collections/virtual_staining/sec61b_joint_mock_v1.yaml create mode 100644 applications/dynacell/configs/collections/virtual_staining/tomm20_joint_all_v1.yaml create mode 100644 applications/dynacell/configs/collections/virtual_staining/tomm20_joint_mock_v1.yaml create mode 100644 applications/dynacell/configs/recipes/models/celldiff_fm_2d.yml create mode 100644 applications/dynacell/configs/recipes/models/fnet2d.yml create mode 100644 applications/dynacell/configs/recipes/models/pix2pix2d_unetvit.yml diff --git a/applications/dynacell/configs/README.md b/applications/dynacell/configs/README.md new file mode 100644 index 000000000..a8c990d8a --- /dev/null +++ b/applications/dynacell/configs/README.md @@ -0,0 +1,26 @@ +# configs + +Hydra/LightningCLI YAML configs for the DynaCell benchmark: reusable fragments, generic examples, and the +runnable benchmark leaves that drive every fit/predict/eval in the paper. + +## Contents + +- **[benchmarks/](benchmarks/README.md)** — the campaign configs. Runnable leaves composed from shared axes, one + per `(organelle, train_set, model)` fit / `(…, predict_set)` predict / eval. This is the tree you run. +- **recipes/** — reusable composition fragments consumed by other configs, grouped by axis: + `data/` (the `hcs_phase_fluor_3d` DataModule), `models/` (per-architecture model init args), `topology/` + (single- vs multi-GPU / GAN DDP), `trainer/` (`fit`/`predict` trainer blocks), `modes/` (`spotlight`). +- **examples/** — generic `fit.yml` + `predict.yml` pair per model family (`celldiff/`, `fnet3d/`, `unetvit3d/`, + `unext2/`) with `#TODO` data-path placeholders. Starting points for a one-off run; see the top-level + [Quickstart](../README.md#quickstart). +- **evaluations/** — legacy per-model shell scripts (`run_eval_*.sh`) that invoke `dynacell evaluate` + directly, grouped by model (`celldiff/`, `fnet3d/`, `unetvit3d/`, `unext2/`, `vscyto3d/`). Predate the + composed Hydra eval leaves under `benchmarks/virtual_staining/_internal/leaf/`; kept for + reference. +- **movies/** — a small crop demo (`2024_11_21_A549_TOMM20_DENV_crop/`): predict configs that render a + cropped A549 TOMM20/DENV time-lapse with iPSC- and joint-trained regression models. + +## Navigation + +- Up: [applications/dynacell](../README.md) +- Subdirectories: [benchmarks/](benchmarks/README.md) diff --git a/applications/dynacell/configs/benchmarks/README.md b/applications/dynacell/configs/benchmarks/README.md new file mode 100644 index 000000000..e28bde41f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/README.md @@ -0,0 +1,15 @@ +# configs/benchmarks + +Runnable benchmark campaigns. Each task subfolder holds composed leaves that are submitted end-to-end via +`tools/submit_benchmark_job.py` (or run directly with `uv run dynacell -c `). + +## Contents + +- **[virtual_staining/](virtual_staining/README.md)** — the DynaCell virtual-staining benchmark: fit / predict / + eval leaves for every `(organelle, model, train_set, predict_set)` combination in the paper, plus the + `_internal/{shared,leaf}` composition system that generates them. + +## Navigation + +- Up: [configs](../README.md) +- Subdirectories: [virtual_staining/](virtual_staining/README.md) diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/README.md b/applications/dynacell/configs/benchmarks/virtual_staining/README.md index 67b03d569..d44b30786 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/README.md +++ b/applications/dynacell/configs/benchmarks/virtual_staining/README.md @@ -34,7 +34,6 @@ virtual_staining/ /// train.yml # LightningCLI fit leaf predict__.yml # LightningCLI predict leaf - eval__.yaml # Hydra eval leaf (canonical location) _internal/ # hidden support tree — not for browsing shared/ model/ @@ -54,8 +53,9 @@ virtual_staining/ eval/ target/.yaml # target_name + benchmark.dataset_ref.target feature_extractor/dynaclr/ # DynaCLR checkpoint + encoder kwargs - leaf/ # symlink tree aliasing canonical eval leaves - ///eval__.yaml -> ../../../../..////eval__.yaml + leaf/ # Hydra eval leaves (leaf=) + grouped//eval_grouped.yaml # benchmark evals: one model load, N conditions + /, instance_ap/, pix2pix_reeval/ # single-condition research leaves ``` Leaves are grouped by **train set** inside each `//` cell so @@ -63,20 +63,19 @@ that a training experiment (train + the predict/eval variants fed by its checkpoint) lives in one directory. Adding a new training run — e.g. the planned `joint_ipsc_confocal_a549_mantis` mix — means creating one new subdir; deleting one is `rm -r`. Each train-set dir holds one `train.yml` -plus one `predict__.yml` and `eval__.yaml` per -held-out split the model is evaluated on. +plus one `predict__.yml` per held-out split the model is +evaluated on. Evaluation is configured separately, in the grouped leaves under +`_internal/leaf/grouped/`. The top level of `virtual_staining/` shows only biology (`er/`, `membrane/`, `mito/`, `nucleus/`) plus `_internal/` — a hidden support tree whose leading underscore signals "implementation detail; don't browse here for science." All Hydra group files, all shared composition building blocks, -and the `leaf/` symlink adapter live under `_internal/`. +and the eval leaves live under `_internal/`. Train/predict leaves use LightningCLI (`.yml`). Eval leaves use Hydra and keep `.yaml` because Hydra's group resolution only discovers `.yaml` files. -The `_internal/leaf/` symlink tree aliases each canonical eval leaf so -Hydra's `leaf=` selector can discover them at -`/leaf/.yaml`. +Hydra's `leaf=` selector finds them at `/leaf/.yaml`. Eval runtime uses two search paths injected by `dynacell.__main__`: `virtual_staining/_internal/` (for the `leaf/` tree) and @@ -148,27 +147,37 @@ queue faster than pinning Hopper. Train leaves stay on `hardware_h200_single.yml` (or `hardware_4gpu.yml` for DDP) because their memory + bandwidth profiles differ. -**Eval leaf** (at `///eval__.yaml`): +**Grouped eval leaf** (at `_internal/leaf/grouped//eval_grouped.yaml`): ```yaml # @package _global_ -defaults: - - override /target: - - override /predict_set: - - override /feature_extractor/dinov3: lvd1689m - - override /feature_extractor/dynaclr: default - -io: - pred_path: /hpc/.../predictions.zarr - +target_name: er compute_feature_metrics: true - -save: - save_dir: /hpc/.../eval_results +conditions: +- name: fnet3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: {dataset: a549-mantis-sec61b-mock, target: sec61b} + io: + pred_path: /hpc/.../prediction.zarr + save: + save_dir: /hpc/.../eval_output ``` ## Running +### Train, validation, and test separation + +The released train and test stores are physically separate and are resolved +from the dataset manifests; benchmark training never reads a test store. During +`fit`, each paper baseline makes an 80/20 position-level train/validation carve +from its resolved train store (`data.init_args.split_ratio: 0.8`). The carve is +deterministic for a given recipe: the paper FNet3D recipe sets +`seed_everything: 0`, while the other paper baseline recipes inherit the +LightningCLI default of `42`. Thus validation is held out from optimization, +but it is a reproducible per-model carve rather than one shared validation +partition across every architecture. The manifest-defined test positions remain +untouched until prediction and evaluation. + The default `trainer.logger` in `configs/recipes/trainer/fit.yml` is `lightning.pytorch.loggers.WandbLogger`. Install dynacell with the `wandb` extra to satisfy this default (`uv add 'dynacell[wandb]'` / @@ -183,9 +192,10 @@ Direct LightningCLI (no sbatch): - `uv run dynacell fit -c configs/benchmarks/virtual_staining////train.yml` - `uv run dynacell predict -c configs/benchmarks/virtual_staining////predict__.yml` -Hydra eval: +Hydra eval (one bucket, or selected conditions of it): -- `uv run dynacell evaluate leaf=///eval__` +- `uv run --package dynacell --extra eval --extra eval_gpu dynacell evaluate-grouped leaf=grouped//eval_grouped` +- `... evaluate-grouped leaf=grouped//eval_grouped 'only_conditions=[]'` Via sbatch with `submit_benchmark_job.py`: @@ -296,3 +306,9 @@ Eval leaves follow the same split on the Hydra side: `io.gt_path`, `io.cell_segmentation_path`, `io.gt_channel_name`, `io.pred_channel_name`, `io.gt_cache_dir`, and `pixel_metrics.spacing` from the manifest. + +## Navigation + +- Up: [benchmarks](../README.md) +- See also: `_internal/leaf/grouped/` [bucket summary](_internal/leaf/grouped/README.md) · + eval-pipeline internals in [dynacell.evaluation](../../../src/dynacell/evaluation/README.md) diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__a549_mantis_denv.yml index 38b7b0a7e..1233f972f 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__a549_mantis_denv.yml @@ -5,7 +5,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__a549_mantis_mock.yml index 6716b9f2e..81326ade6 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__a549_mantis_mock.yml @@ -5,7 +5,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__a549_mantis_zikv.yml index f02835959..3d6f59533 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__a549_mantis_zikv.yml @@ -5,7 +5,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__hek_mantis_kras_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__hek_mantis_kras_a549xy.yml new file mode 100644 index 000000000..78e1101af --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__hek_mantis_kras_a549xy.yml @@ -0,0 +1,57 @@ +# VSCyto3D-Cytoland predict: dual nucleus+membrane (no FT) on the HEK293T probe. +# +# Sole consumer is the HEK carved whole-cell membrane eval: the HEK release has +# no nucleus channel, so `Nuclei_prediction` here supplies the carve seeds that +# leaf/grouped/membrane_hek_a549xy/eval_grouped.yaml cpdino-segments and +# subtracts from the cpdino whole-cell membrane labels. `Membrane_prediction` is +# a by-product of the 2-channel head and is not scored anywhere — the benchmarked +# HEK membrane predictions come from the membrane/* leaves. +# +# Public cytoland weights on purpose: this model never saw HEK or any dynacell +# fine-tuning, so the seeds do not leak a benchmarked checkpoint into the eval of +# that same checkpoint. Every model condition in the HEK bucket carves the same +# seed stack, so the carve stays a constant across the arms being compared. +# +# ckpt / data init_args lifted verbatim from the sibling predict__a549_mantis_mock.yml. +base: + - ../../../_internal/shared/model/predict_sets/hek_mantis_dual_a549xy.yml + - ../../../_internal/shared/model/targets/dual_nucl_memb.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: dual_nucl_memb + trained_on: cytoland + predict_set: hek_mantis_dual_a549xy + model_name: fcmae_vscyto3d_pretrained_cytoland + experiment_id: dual_nucl_memb__cytoland__fcmae_vscyto3d_pretrained__hek_mantis_kras_a549xy + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/datasets/public/VS_models/VSCyto3D/epoch=83-step=14532-loss=0.492.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/hek/predictions/dual_nucl_memb_fcmae_vscyto3d_pretrained_cytoland_a549xy.zarr + +launcher: + job_name: FCMAE_VSCyto3D_Cytoland_PRED_DUAL_ON_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/hek/predictions + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__ipsc_confocal.yml index c121b8a0e..605c7fa32 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__ipsc_confocal.yml @@ -6,7 +6,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__ipsc_confocal_smoke.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__ipsc_confocal_smoke.yml index 00f88ca36..db215a9f6 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__ipsc_confocal_smoke.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__ipsc_confocal_smoke.yml @@ -6,7 +6,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_infectionft/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_infectionft/predict__a549_mantis_denv.yml index 364d4c56f..99db6d4d5 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_infectionft/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_infectionft/predict__a549_mantis_denv.yml @@ -5,7 +5,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -18,7 +18,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/organelle_phenotyping/models/VSCyto3D-A549-infection-finetune/4gpu_bf16_bs16_to_ep7/checkpoints/epoch=7-step=832.ckpt + ckpt_path: /hpc/projects/organelle_phenotyping/models/Cytoland-VSCyto3D_A549-infection-finetune/4gpu_bf16_bs16_to_ep7/checkpoints/epoch=7-step=832.ckpt data: init_args: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_infectionft/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_infectionft/predict__a549_mantis_mock.yml index fa8203136..d2b81b92f 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_infectionft/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_infectionft/predict__a549_mantis_mock.yml @@ -5,7 +5,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -18,7 +18,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/organelle_phenotyping/models/VSCyto3D-A549-infection-finetune/4gpu_bf16_bs16_to_ep7/checkpoints/epoch=7-step=832.ckpt + ckpt_path: /hpc/projects/organelle_phenotyping/models/Cytoland-VSCyto3D_A549-infection-finetune/4gpu_bf16_bs16_to_ep7/checkpoints/epoch=7-step=832.ckpt data: init_args: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_infectionft/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_infectionft/predict__a549_mantis_zikv.yml index 1f6a3eec7..e3f282d15 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_infectionft/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_infectionft/predict__a549_mantis_zikv.yml @@ -5,7 +5,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -18,7 +18,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/organelle_phenotyping/models/VSCyto3D-A549-infection-finetune/4gpu_bf16_bs16_to_ep7/checkpoints/epoch=7-step=832.ckpt + ckpt_path: /hpc/projects/organelle_phenotyping/models/Cytoland-VSCyto3D_A549-infection-finetune/4gpu_bf16_bs16_to_ep7/checkpoints/epoch=7-step=832.ckpt data: init_args: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_infectionft/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_infectionft/predict__ipsc_confocal.yml index d2fd37cbc..3f139d3b4 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_infectionft/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_infectionft/predict__ipsc_confocal.yml @@ -6,7 +6,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -19,7 +19,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/organelle_phenotyping/models/VSCyto3D-A549-infection-finetune/4gpu_bf16_bs16_to_ep7/checkpoints/epoch=7-step=832.ckpt + ckpt_path: /hpc/projects/organelle_phenotyping/models/Cytoland-VSCyto3D_A549-infection-finetune/4gpu_bf16_bs16_to_ep7/checkpoints/epoch=7-step=832.ckpt data: init_args: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/predict__a549_mantis_denv.yml index 66ab4d93f..b8a41e9b3 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/predict__a549_mantis_denv.yml @@ -6,7 +6,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/predict__a549_mantis_mock.yml index cb75ceb69..a28fedd79 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/predict__a549_mantis_mock.yml @@ -6,7 +6,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/predict__a549_mantis_zikv.yml index 8cd4a03df..596bbf696 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/predict__a549_mantis_zikv.yml @@ -6,7 +6,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/predict__ipsc_confocal.yml index e9bdb9ddb..f428206ef 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/predict__ipsc_confocal.yml @@ -6,7 +6,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/train.yml index e1b136fcb..276bf6903 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/a549_mantis/train.yml @@ -48,6 +48,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/predict__a549_mantis_denv.yml index db204e526..f00313bbf 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/predict__a549_mantis_denv.yml @@ -6,7 +6,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/predict__a549_mantis_mock.yml index 18237c97f..49e187c7c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/predict__a549_mantis_mock.yml @@ -6,7 +6,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/predict__a549_mantis_zikv.yml index b94461b79..88a56d0ee 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -6,7 +6,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/predict__ipsc_confocal.yml index f545aa20f..c8f299433 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/predict__ipsc_confocal.yml @@ -6,7 +6,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/train.yml index 9ecd0b8ca..9387b6e4a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_cytolandft/ipsc_confocal/train.yml @@ -48,6 +48,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/predict__a549_mantis_denv.yml index b7aa49b76..017f3120b 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/predict__a549_mantis_denv.yml @@ -6,7 +6,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/predict__a549_mantis_mock.yml index ecaaacf62..be2a99b84 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/predict__a549_mantis_mock.yml @@ -6,7 +6,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/predict__a549_mantis_zikv.yml index 2a6cc320a..2fe2b90ae 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/predict__a549_mantis_zikv.yml @@ -6,7 +6,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/predict__ipsc_confocal.yml index df65e3ccc..a0e992531 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/predict__ipsc_confocal.yml @@ -6,7 +6,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/train.yml index 4d3664d46..4ea172194 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/a549_mantis/train.yml @@ -34,7 +34,7 @@ data: model: init_args: - ckpt_path: /hpc/projects/organelle_phenotyping/models/VSCyto3D-A549-infection-finetune/4gpu_bf16_bs16_to_ep7/checkpoints/epoch=7-step=832.ckpt + ckpt_path: /hpc/projects/organelle_phenotyping/models/Cytoland-VSCyto3D_A549-infection-finetune/4gpu_bf16_bs16_to_ep7/checkpoints/epoch=7-step=832.ckpt trainer: logger: @@ -48,6 +48,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/predict__a549_mantis_denv.yml index 4563d616d..2ce3b2ed2 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/predict__a549_mantis_denv.yml @@ -6,7 +6,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/predict__a549_mantis_mock.yml index 81b3b48d6..7148034d7 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/predict__a549_mantis_mock.yml @@ -6,7 +6,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/predict__a549_mantis_zikv.yml index c39a4a573..dced74e45 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -6,7 +6,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/predict__ipsc_confocal.yml index de97a81f9..09881d107 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/predict__ipsc_confocal.yml @@ -6,7 +6,7 @@ base: - ../../../_internal/shared/model/targets/dual_nucl_memb.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/train.yml index 211506a16..9b999f3d3 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_dual_nucl_memb/vscyto3d_infectionft_dynacellft/ipsc_confocal/train.yml @@ -34,7 +34,7 @@ data: model: init_args: - ckpt_path: /hpc/projects/organelle_phenotyping/models/VSCyto3D-A549-infection-finetune/4gpu_bf16_bs16_to_ep7/checkpoints/epoch=7-step=832.ckpt + ckpt_path: /hpc/projects/organelle_phenotyping/models/Cytoland-VSCyto3D_A549-infection-finetune/4gpu_bf16_bs16_to_ep7/checkpoints/epoch=7-step=832.ckpt trainer: logger: @@ -48,6 +48,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index bf10d7589..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../er/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index a4c5ea9be..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../er/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index a15141b73..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../er/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 120000 index 237286899..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../er/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index 2e2ea2bdf..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index f6177069d..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index 42ee842e6..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index 252099ab4..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index 296ab3ad9..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index ee8c4f389..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index e52418d5e..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index 3e637e458..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index 795e29808..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/phase/eval__a549_mantis_sec61b_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/phase/eval__a549_mantis_sec61b_denv.yaml new file mode 100644 index 000000000..fce04145a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/phase/eval__a549_mantis_sec61b_denv.yaml @@ -0,0 +1,21 @@ +# @package _global_ +# Phase baseline (no model): the raw Phase3D input scored as the "prediction" +# against the A549 denv ER (sec61b) GT. io.pred_is_source reads Phase3D and +# defaults io.pred_path to the GT store, so positions match by construction. +# Diffuse organelle: supermodel semantic + manifest cell_segmentation_path +# (no cpdino backend / instance AP, unlike the nucleus/membrane phase leaves). +defaults: + - override /target: er_sec61b + - override /predict_set: a549_mantis_sec61b_denv + +benchmark: + dataset_ref: + target: sec61b + +io: + pred_is_source: true + +compute_feature_metrics: true + +save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_phase_er_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/phase/eval__a549_mantis_sec61b_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/phase/eval__a549_mantis_sec61b_mock.yaml new file mode 100644 index 000000000..368e6c9ae --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/phase/eval__a549_mantis_sec61b_mock.yaml @@ -0,0 +1,21 @@ +# @package _global_ +# Phase baseline (no model): the raw Phase3D input scored as the "prediction" +# against the A549 mock ER (sec61b) GT. io.pred_is_source reads Phase3D and +# defaults io.pred_path to the GT store, so positions match by construction. +# Diffuse organelle: supermodel semantic + manifest cell_segmentation_path +# (no cpdino backend / instance AP, unlike the nucleus/membrane phase leaves). +defaults: + - override /target: er_sec61b + - override /predict_set: a549_mantis_sec61b_mock + +benchmark: + dataset_ref: + target: sec61b + +io: + pred_is_source: true + +compute_feature_metrics: true + +save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_phase_er_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/phase/eval__a549_mantis_sec61b_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/phase/eval__a549_mantis_sec61b_zikv.yaml new file mode 100644 index 000000000..312a4face --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/phase/eval__a549_mantis_sec61b_zikv.yaml @@ -0,0 +1,21 @@ +# @package _global_ +# Phase baseline (no model): the raw Phase3D input scored as the "prediction" +# against the A549 zikv ER (sec61b) GT. io.pred_is_source reads Phase3D and +# defaults io.pred_path to the GT store, so positions match by construction. +# Diffuse organelle: supermodel semantic + manifest cell_segmentation_path +# (no cpdino backend / instance AP, unlike the nucleus/membrane phase leaves). +defaults: + - override /target: er_sec61b + - override /predict_set: a549_mantis_sec61b_zikv + +benchmark: + dataset_ref: + target: sec61b + +io: + pred_is_source: true + +compute_feature_metrics: true + +save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_phase_er_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/phase/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/phase/eval__ipsc_confocal.yaml new file mode 100644 index 000000000..899e49c42 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/phase/eval__ipsc_confocal.yaml @@ -0,0 +1,16 @@ +# @package _global_ +# Phase baseline (no model): the raw Phase3D input scored as the "prediction" +# against the iPSC ER GT. io.pred_is_source reads the manifest source +# channel (Phase3D) and defaults io.pred_path to the GT store. Diffuse organelle: +# supermodel semantic + manifest cell_segmentation_path (no cpdino / instance AP). +defaults: + - override /target: er_sec61b + - override /predict_set: ipsc_confocal + +io: + pred_is_source: true + +compute_feature_metrics: true + +save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_phase_er diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index 71612648e..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../er/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index 83c1332e3..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../er/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index ff3a386de..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../er/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 120000 index 9c0e95db5..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/er/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../er/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/README.md b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/README.md index 4b1bdabda..11d48000e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/README.md +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/README.md @@ -4,17 +4,17 @@ Auto-generated by `applications/dynacell/tools/generate_grouped_eval_configs.py` | Organelle | Train set | Conditions | |---|---|---| | er | ipsc_trained | 26 | -| er | joint | 16 | -| er | a549_trained | 16 | +| er | joint | 24 | +| er | a549_trained | 24 | | mitochondria | ipsc_trained | 22 | -| mitochondria | joint | 16 | -| mitochondria | a549_trained | 16 | +| mitochondria | joint | 24 | +| mitochondria | a549_trained | 24 | | nucleus | ipsc_trained | 26 | | nucleus | joint | 20 | | nucleus | a549_trained | 20 | | membrane | ipsc_trained | 26 | -| membrane | joint | 16 | -| membrane | a549_trained | 16 | +| membrane | joint | 20 | +| membrane | a549_trained | 20 | ## Probe leaf diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/_probe/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/_probe/eval_grouped.yaml index 3a9e0e3a6..252c54e69 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/_probe/eval_grouped.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/_probe/eval_grouped.yaml @@ -12,63 +12,63 @@ runtime: force_recompute: final_metrics: true conditions: +- name: celldiff_r2__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/a549__denv/prediction.zarr + pred_cache_dir: /tmp/reeval_probe/cache/celldiff_r2__a549_trained__a549_denv + save: + save_dir: /tmp/reeval_probe/out/celldiff_r2__a549_trained__a549_denv - name: celldiff_r2__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_celldiff_r2_a549trained.zarr + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/ipsc/prediction.zarr pred_cache_dir: /tmp/reeval_probe/cache/celldiff_r2__a549_trained__ipsc save: save_dir: /tmp/reeval_probe/out/celldiff_r2__a549_trained__ipsc -- name: celldiff_r2_denoise__ipsc_trained__ipsc +- name: celldiff_r2__joint__a549_denv benchmark: dataset_ref: - dataset: aics-hipsc + dataset: a549-mantis-sec61b-denv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_celldiff_r2_denoise.zarr - pred_cache_dir: /tmp/reeval_probe/cache/celldiff_r2_denoise__ipsc_trained__ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/a549__denv/prediction.zarr + pred_cache_dir: /tmp/reeval_probe/cache/celldiff_r2__joint__a549_denv save: - save_dir: /tmp/reeval_probe/out/celldiff_r2_denoise__ipsc_trained__ipsc -- name: vscyto3d__joint__ipsc + save_dir: /tmp/reeval_probe/out/celldiff_r2__joint__a549_denv +- name: celldiff_r2__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_fcmae_vscyto3d_pretrained_jointtrained.zarr - pred_cache_dir: /tmp/reeval_probe/cache/vscyto3d__joint__ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/ipsc/prediction.zarr + pred_cache_dir: /tmp/reeval_probe/cache/celldiff_r2__joint__ipsc save: - save_dir: /tmp/reeval_probe/out/vscyto3d__joint__ipsc -- name: celldiff_r2__a549_trained__a549_denv + save_dir: /tmp/reeval_probe/out/celldiff_r2__joint__ipsc +- name: celldiff_r2_denoise__ipsc_trained__ipsc benchmark: dataset_ref: - dataset: a549-mantis-sec61b-denv + dataset: aics-hipsc target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_celldiff_r2_a549trained_denv.zarr - pred_cache_dir: /tmp/reeval_probe/cache/celldiff_r2__a549_trained__a549_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_denoise/ipsc/ipsc/prediction.zarr + pred_cache_dir: /tmp/reeval_probe/cache/celldiff_r2_denoise__ipsc_trained__ipsc save: - save_dir: /tmp/reeval_probe/out/celldiff_r2__a549_trained__a549_denv + save_dir: /tmp/reeval_probe/out/celldiff_r2_denoise__ipsc_trained__ipsc - name: celldiff_r2_iterative__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-sec61b-denv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_celldiff_r2_iterative__sec61b_denv.zarr + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr pred_cache_dir: /tmp/reeval_probe/cache/celldiff_r2_iterative__ipsc_trained__a549_denv save: save_dir: /tmp/reeval_probe/out/celldiff_r2_iterative__ipsc_trained__a549_denv -- name: vscyto3d__joint__a549_denv - benchmark: - dataset_ref: - dataset: a549-mantis-sec61b-denv - target: sec61b - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained_jointtrained_denv.zarr - pred_cache_dir: /tmp/reeval_probe/cache/vscyto3d__joint__a549_denv - save: - save_dir: /tmp/reeval_probe/out/vscyto3d__joint__a549_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er__2d_focus2d_pix2pix2d_wmatch/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er__2d_focus2d_pix2pix2d_wmatch/eval_grouped.yaml new file mode 100644 index 000000000..7d7c4aa3f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er__2d_focus2d_pix2pix2d_wmatch/eval_grouped.yaml @@ -0,0 +1,167 @@ +# @package _global_ +# pix2pix2d warmup-matched refit: the pix2pix2d conditions of the er +# 2D focus2d buckets (and seed1 bucket), on the pix2pix2d_unetvit_wmatch[_seed1] stores. +# Same recipe, planes and caches as those buckets. Written by +# applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +focus2d: + halfwidth: 1 +segmentation: + focus_anchor: nucleus_area + nuclei_channel_name: Nuclei +conditions: +- name: pix2pix2d_wmatch__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit_wmatch/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit_wmatch/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d_wmatch__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit_wmatch/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit_wmatch/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d_wmatch__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d_wmatch__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/pix2pix2d_unetvit_wmatch/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit_wmatch/ipsc/ipsc +- name: pix2pix2d_wmatch__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit_wmatch/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit_wmatch/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d_wmatch__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit_wmatch/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit_wmatch/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d_wmatch__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit_wmatch/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit_wmatch/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d_wmatch__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/pix2pix2d_unetvit_wmatch/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit_wmatch/a549/ipsc +- name: pix2pix2d_wmatch__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit_wmatch/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit_wmatch/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d_wmatch__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit_wmatch/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit_wmatch/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d_wmatch__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit_wmatch/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit_wmatch/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d_wmatch__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/pix2pix2d_unetvit_wmatch/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit_wmatch/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_bf_trained/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_bf_trained/eval_grouped.yaml new file mode 100644 index 000000000..496ed64aa --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_bf_trained/eval_grouped.yaml @@ -0,0 +1,94 @@ +# @package _global_ +# Grouped leaf: er bucket, a549_bf_trained models (8 conditions). Auto-generated by tools/generate_grouped_eval_configs.py. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +conditions: +- name: celldiff_r2_iterative__a549_bf_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/a549__bf/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_r2_iterative/a549__bf/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/a549__bf/a549__denv +- name: fnet3d__a549_bf_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549__bf/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_paper/a549__bf/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549__bf/a549__denv +- name: celldiff_r2_iterative__a549_bf_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/a549__bf/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_r2_iterative/a549__bf/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/a549__bf/a549__mock +- name: fnet3d__a549_bf_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549__bf/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_paper/a549__bf/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549__bf/a549__mock +- name: celldiff_r2_iterative__a549_bf_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/a549__bf/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_r2_iterative/a549__bf/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/a549__bf/a549__zikv +- name: fnet3d__a549_bf_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549__bf/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_paper/a549__bf/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549__bf/a549__zikv +- name: celldiff_r2_iterative__a549_bf_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/a549__bf/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/celldiff_r2_iterative/a549__bf/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/a549__bf/ipsc +- name: fnet3d__a549_bf_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549__bf/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fnet3d_paper/a549__bf/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549__bf/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained/eval_grouped.yaml index 0f1a93e7f..05c1c4504 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained/eval_grouped.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained/eval_grouped.yaml @@ -1,5 +1,5 @@ # @package _global_ -# Grouped leaf: er bucket, a549_trained models (16 conditions). Auto-generated by tools/generate_grouped_eval_configs.py. +# Grouped leaf: er bucket, a549_trained models (24 conditions). Auto-generated by tools/generate_grouped_eval_configs.py. target_name: er compute_feature_metrics: true use_gpu: true @@ -18,157 +18,237 @@ conditions: dataset: a549-mantis-sec61b-denv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_celldiff_r2_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/celldiff_r2/sec61b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_r2/a549/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_er_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/a549__denv - name: vscyto3d__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-sec61b-denv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/sec61b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto3d_pretrained/a549/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_er_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/a549__denv - name: unext2__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-sec61b-denv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/sec61b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto3d_scratch/a549/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_er_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/a549__denv - name: fnet3d__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-sec61b-denv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fnet3d_paper_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fnet3d_paper/sec61b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_paper/a549/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_er_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/a549__denv +- name: pix2pix3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix3d_unetvit/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__denv +- name: unetvit3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/unetvit3d/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/a549__denv - name: celldiff_r2__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-sec61b-mock target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_celldiff_r2_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/celldiff_r2/sec61b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_r2/a549/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_er_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/a549__mock - name: vscyto3d__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-sec61b-mock target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/sec61b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto3d_pretrained/a549/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_er_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/a549__mock - name: unext2__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-sec61b-mock target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/sec61b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto3d_scratch/a549/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_er_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/a549__mock - name: fnet3d__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-sec61b-mock target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fnet3d_paper_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fnet3d_paper/sec61b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_paper/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/a549__mock +- name: pix2pix3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix3d_unetvit/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__mock +- name: unetvit3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/unetvit3d/a549/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_er_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/a549__mock - name: celldiff_r2__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-sec61b-zikv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_celldiff_r2_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/celldiff_r2/sec61b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_r2/a549/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_er_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/a549__zikv - name: vscyto3d__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-sec61b-zikv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/sec61b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto3d_pretrained/a549/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_er_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/a549__zikv - name: unext2__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-sec61b-zikv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/sec61b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto3d_scratch/a549/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_er_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/a549__zikv - name: fnet3d__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-sec61b-zikv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fnet3d_paper_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fnet3d_paper/sec61b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_paper/a549/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_er_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/a549__zikv +- name: pix2pix3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix3d_unetvit/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__zikv +- name: unetvit3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/unetvit3d/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/a549__zikv - name: celldiff_r2__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_celldiff_r2_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/celldiff_r2/er_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/celldiff_r2/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_er + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/ipsc - name: vscyto3d__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_fcmae_vscyto3d_pretrained_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/er_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fcmae_vscyto3d_pretrained/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_er + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/ipsc - name: unext2__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_fcmae_vscyto3d_scratch_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/er_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fcmae_vscyto3d_scratch/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_er + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/ipsc - name: fnet3d__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_fnet3d_paper_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/fnet3d_paper/er_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fnet3d_paper/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/ipsc +- name: pix2pix3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/pix2pix3d_unetvit/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/ipsc +- name: unetvit3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/unetvit3d/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_er + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__2d/eval_grouped.yaml new file mode 100644 index 000000000..16dbe7ea5 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__2d/eval_grouped.yaml @@ -0,0 +1,282 @@ +# @package _global_ +# Focused sibling of grouped/er_a549_trained: ONLY the in-focus 2D conditions -- +# fnet2d + FCMAE-2D (unext2_2d, vscyto2d) + celldiff_2d + pix2pix2d +# x {ipsc, a549 mock/denv/zikv} = 20. +# Condition blocks are copied verbatim from a generate_grouped_eval_configs.py run, +# so they stay byte-identical to what the canonical bucket would emit -- only the +# selection is narrowed. +# +# celldiff_2d was folded in on 2026-08-04, once its predicts finished. It was held +# out until then because the generator's only freshness gate is pred_path.is_dir(), +# which passes on a partially-written store (measured 4813 of 5787 chunk files on a +# live nucleus/celldiff_2d/ipsc/a549__denv). The gate applied by hand instead was a +# per-store chunk count against the fnet2d store for the same organelle/pool/bucket, +# required to match exactly. The complete size is a property of (organelle, bucket), +# not a constant: 4270-4300 on the iPSC buckets and 5211-5787 on the A549 ones, and +# er/a549__denv is the low outlier at 5211 in EVERY pool. That one was confirmed +# against two further fully-evaluated models (both FCMAE-2D arms, also 5211, same 12 +# FOVs) so it is the true size and not a shortfall shared with the reference -- which +# a fnet2d-relative gate cannot see by itself. Plus sacct COMPLETED 0:0 on all 48 +# CELLDiff2D_PRED jobs. +# +# pix2pix2d was folded in on 2026-08-05, once its 48 predicts finished (all COMPLETED +# 0:0). Held out for the same reason, but gated harder than celldiff_2d was: per array, +# the expected chunk count = prod(ceil(shape / chunks)) read analytically from that +# array's own zarr.json, compared against the files actually present. That catches a +# truncated write inside a position without needing a reference family at all, which +# is what a fnet2d-relative count could not do. It is paired with a position-set +# comparison against a family already known complete, because a store missing whole +# FOVs is internally self-consistent and its own metadata can never reveal the gap. +# All 48 passed both checks: 100 positions per iPSC bucket, 12 per A549 bucket, every +# array fully chunked (.tmp/pix2pix2d/verify_predict_stores.py). +# +# Why a sibling instead of folding the 2D models into the canonical bucket: +# 1. The generator sets force_recompute.final_metrics: true, so the canonical +# bucket's already-evaluated 3D conditions would ALL recompute, not cache-skip. +# 2. Fairness. The global pixel metrics (PCC/SSIM/FSC/PSNR/Spectral_PCC), +# MicroMS3IM and the CP regionprops are computed over the FULL 3D volume, +# while per-cell similarity, the deep features (DINOv3/DynaCLR/CellDINO/ +# MorphEm) and instance AP are focus-restricted (pipeline.py). Only the +# focus-restricted families are a fair 2D-vs-3D comparison -- a per-z 2D model +# is penalised by the volume-reconstruction columns for planes it never +# targeted (2d-infocus-vs-models.md 1a). The full-3D columns are still +# computed here as diagnostics; they are NOT publishable as 2D-vs-3D. +# +# force_recompute: every pred_* artifact is forced, plus final_metrics. +# +# Until 2026-09-10 this block was `final_metrics: false`, on the grounds that 16 of +# the 20 conditions were already fully evaluated (verified 2026-08-05) and could +# cache-skip. That is now WRONG and the flag is inverted: an affine bug blanked the +# training data at z_window_size=1 (fixed in VisCy 9640537d), so 4 of the 5 2D +# families -- pix2pix2d, celldiff_2d and both FCMAE-2D arms -- were retrained from +# scratch and ALL 192 2D predictions were regenerated 2026-09-10..14. fnet2d is the +# only family that was never affected (flip-only augmentation). +# +# The prediction stores were rewritten IN PLACE with --overwrite, and the eval caches +# carry no prediction provenance -- nothing in the cache key changes when the pixels +# behind it change. So `final_metrics: true` alone is NOT enough: it would recompute +# the summary while still reading August's cached masks, instances and deep features. +# Every pred_* flag has to be forced for the numbers to reflect the new predictions. +# +# gt_* stays false deliberately. The ground truth did not change, and the GT-side deep +# features are the expensive half of a cold extraction. Do not set force_recompute.all +# -- it forces gt_* too (see _resolve_force in evaluation/pipeline_cache.py). +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: celldiff_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_2d/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/a549__denv +- name: vscyto2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_pretrained/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/a549__denv +- name: unext2_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/a549__denv +- name: fnet2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/a549__denv +- name: pix2pix2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/a549__denv +- name: celldiff_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_2d/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/a549__mock +- name: vscyto2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_pretrained/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/a549__mock +- name: unext2_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/a549__mock +- name: fnet2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/a549__mock +- name: pix2pix2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/a549__mock +- name: celldiff_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_2d/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/a549__zikv +- name: vscyto2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_pretrained/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/a549__zikv +- name: unext2_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/a549__zikv +- name: fnet2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/a549__zikv +- name: pix2pix2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/a549__zikv +- name: celldiff_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/celldiff_2d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/ipsc +- name: vscyto2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fcmae_vscyto2d_pretrained/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/ipsc +- name: unext2_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fcmae_vscyto2d_scratch/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/ipsc +- name: fnet2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fnet2d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/ipsc +- name: pix2pix2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/pix2pix2d_unetvit/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__2d_focus2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__2d_focus2d/eval_grouped.yaml new file mode 100644 index 000000000..878681273 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__2d_focus2d/eval_grouped.yaml @@ -0,0 +1,265 @@ +# @package _global_ +# 2D benchmark (focus2d.halfwidth=1): every metric on one GT-anchored focus plane per +# FOV/timepoint -- pixel metrics, MicroMS3IM and CP on the plane, deep features and per-cell +# similarity on its 3-plane slab, semantic masks segmented on the slab and scored on its +# plane. The 3D benchmark keeps the full volume in the canonical dirs; this bucket never +# writes there (save_dir re-rooted under +# /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/). Conditions: the 20 of +# er_a549_trained__2d (5 2D families x 4 test sets), predictions unchanged. Plane anchor: +# nucleus_area on the GT Nuclei channel for iPSC, phase_midband for A549 (no nuclei). Caches: +# /focus2d_h1/ (GT and pred); CP reference __focus2d_h1. Generated by +# applications/dynacell/experiments/2026-10-07_2d-vs-3d-cost/make_focus2d_buckets.py. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +focus2d: + halfwidth: 1 +segmentation: + focus_anchor: nucleus_area + nuclei_channel_name: Nuclei +conditions: +- name: celldiff_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_2d/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/celldiff_2d/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_pretrained/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_pretrained/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_scratch/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fnet2d/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_2d/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/celldiff_2d/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_pretrained/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_pretrained/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_scratch/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: fnet2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fnet2d/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_2d/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/celldiff_2d/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_pretrained/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_pretrained/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_scratch/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fnet2d/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/celldiff_2d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/celldiff_2d/a549/ipsc +- name: vscyto2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fcmae_vscyto2d_pretrained/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_pretrained/a549/ipsc +- name: unext2_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fcmae_vscyto2d_scratch/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_scratch/a549/ipsc +- name: fnet2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fnet2d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fnet2d/a549/ipsc +- name: pix2pix2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/pix2pix2d_unetvit/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__2d_focusslab3/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__2d_focusslab3/eval_grouped.yaml new file mode 100644 index 000000000..70ced59c6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__2d_focusslab3/eval_grouped.yaml @@ -0,0 +1,542 @@ +# @package _global_ +# 2D benchmark, ER/mito segmentation on the focus plane ("slab3"): the 3 planes centered on +# each FOV's focus plane are segmented as one small volume and only the focus plane of +# the mask is scored (focus2d.halfwidth=1, the 2D-benchmark eval mode). The 3D benchmark keeps +# whole-volume masks in the canonical eval dirs; this bucket never writes there. +# +# Models: the five 2D families from er_a549_trained__2d and the 3D models from er_a549_trained +# (CELL-Diff3D = the iterative sampler only), x the four test sets. +# Plane anchor: nucleus_area on the GT Nuclei channel for the iPSC test set, +# phase_midband (GT Phase3D) for A549, whose SEC61B/TOMM20 stores carry no nuclei. +# +# Output: save_dir = canonical eval dir re-rooted under /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/. Only mask_metrics.* are +# the product. Feature metrics, MicroMS3IM, FSC and Spectral PCC are off (pixel_metrics.csv +# holds the other focus-plane pixel metrics); masks are not cached (milliseconds per slab). +# Generated by applications/dynacell/experiments/2026-10-06_2d-focus-slab3/make_buckets.py. +target_name: er +compute_feature_metrics: false +compute_microssim: false +use_gpu: true +io: + require_complete_cache: false +pixel_metrics: + fsc: null + spectral_pcc: null +focus2d: + halfwidth: 1 +segmentation: + focus_anchor: nucleus_area + nuclei_channel_name: Nuclei +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +conditions: +- name: celldiff_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_2d/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_pretrained/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_scratch/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet2d/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix2d_unetvit/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_2d/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_pretrained/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_scratch/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: fnet2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet2d/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix2d_unetvit/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_2d/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_pretrained/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_scratch/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet2d/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix2d_unetvit/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_2d/a549/ipsc +- name: vscyto2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_pretrained/a549/ipsc +- name: unext2_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_scratch/a549/ipsc +- name: fnet2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet2d/a549/ipsc +- name: pix2pix2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix2d_unetvit/a549/ipsc +- name: celldiff_r2__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_r2/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: vscyto3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_pretrained/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unext2__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_scratch/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: fnet3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet3d_paper/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix3d_unetvit/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unetvit3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/unetvit3d/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: celldiff_r2__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_r2/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: vscyto3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_pretrained/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unext2__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_scratch/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: fnet3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet3d_paper/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix3d_unetvit/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unetvit3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/unetvit3d/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: celldiff_r2__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_r2/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: vscyto3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_pretrained/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unext2__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_scratch/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: fnet3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet3d_paper/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix3d_unetvit/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unetvit3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/unetvit3d/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: celldiff_r2__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_r2/a549/ipsc +- name: vscyto3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_pretrained/a549/ipsc +- name: unext2__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_scratch/a549/ipsc +- name: fnet3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet3d_paper/a549/ipsc +- name: pix2pix3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix3d_unetvit/a549/ipsc +- name: unetvit3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/unetvit3d/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__lite/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__lite/eval_grouped.yaml new file mode 100644 index 000000000..3def1fd11 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__lite/eval_grouped.yaml @@ -0,0 +1,219 @@ +# @package _global_ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained/eval_grouped.yaml. Do not edit; regenerate. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +compute_microssim: false +feature_metrics: + compute_fid: false + compute_prc: false + compute_mind: false +conditions: +- name: celldiff_r2__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/celldiff_r2/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/a549/a549__denv +- name: vscyto3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/fcmae_vscyto3d_pretrained/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/a549/a549__denv +- name: unext2__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/fcmae_vscyto3d_scratch/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/a549/a549__denv +- name: fnet3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/fnet3d_paper/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/a549/a549__denv +- name: unetvit3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/unetvit3d/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/a549/a549__denv +- name: celldiff_r2__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/celldiff_r2/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/a549/a549__mock +- name: vscyto3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/fcmae_vscyto3d_pretrained/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/a549/a549__mock +- name: unext2__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/fcmae_vscyto3d_scratch/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/a549/a549__mock +- name: fnet3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/fnet3d_paper/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/a549/a549__mock +- name: unetvit3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/unetvit3d/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/a549/a549__mock +- name: celldiff_r2__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/celldiff_r2/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/a549/a549__zikv +- name: vscyto3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/fcmae_vscyto3d_pretrained/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/a549/a549__zikv +- name: unext2__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/fcmae_vscyto3d_scratch/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/a549/a549__zikv +- name: fnet3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/fnet3d_paper/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/a549/a549__zikv +- name: unetvit3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/unetvit3d/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/a549/a549__zikv +- name: celldiff_r2__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/er/celldiff_r2/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/a549/ipsc +- name: vscyto3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/er/fcmae_vscyto3d_pretrained/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/a549/ipsc +- name: unext2__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/er/fcmae_vscyto3d_scratch/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/a549/ipsc +- name: fnet3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/er/fnet3d_paper/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/a549/ipsc +- name: unetvit3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/er/unetvit3d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__temporal/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__temporal/eval_grouped.yaml new file mode 100644 index 000000000..68ad4bbd4 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_a549_trained__temporal/eval_grouped.yaml @@ -0,0 +1,92 @@ +# @package _global_ +# Focused sibling of grouped/er_a549_trained: ONLY the 6 Phase 17 FNet3D +# temporal-sampling conditions (fnet3d_t01, fnet3d_tspread x a549 mock/denv/zikv). +# Condition blocks are copied verbatim from a generate_grouped_eval_configs.py run, +# so they stay byte-identical to what the canonical bucket would emit -- only the +# selection is narrowed. +# +# The two arms trained on equal frame budgets drawn differently in time: `t01` on +# timepoints {0,1} (hpi 5 and 7) only, `tspread` spread over the whole course. The +# A549 test set spans hpi 5->23, so these predicts are the ONLY valid cross-arm +# comparison: each arm validates on its own frame subset, which makes +# `loss/validate` incomparable across arms. Measured best-val bears this out -- +# nucleus favours t01 (0.027 vs 0.109) while ER favours tspread (0.747 vs 0.405), +# i.e. the ordering flips by organelle and means nothing. +# +# Why not run the canonical bucket: the generator sets +# force_recompute.final_metrics: true, so its already-evaluated conditions would +# all recompute instead of cache-skipping. +# +# All 6 conditions are brand new, so nothing is cached. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +conditions: +- name: fnet3d_t01__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_t01/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_t01/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_t01/a549/a549__denv +- name: fnet3d_tspread__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_tspread/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_tspread/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_tspread/a549/a549__denv +- name: fnet3d_t01__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_t01/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_t01/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_t01/a549/a549__mock +- name: fnet3d_tspread__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_tspread/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_tspread/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_tspread/a549/a549__mock +- name: fnet3d_t01__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_t01/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_t01/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_t01/a549/a549__zikv +- name: fnet3d_tspread__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_tspread/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_tspread/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_tspread/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_bf_trained/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_bf_trained/eval_grouped.yaml new file mode 100644 index 000000000..be9dd82dd --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_bf_trained/eval_grouped.yaml @@ -0,0 +1,94 @@ +# @package _global_ +# Grouped leaf: er bucket, ipsc_bf_trained models (8 conditions). Auto-generated by tools/generate_grouped_eval_configs.py. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +conditions: +- name: celldiff_r2_iterative__ipsc_bf_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc__bf/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_r2_iterative/ipsc__bf/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc__bf/a549__denv +- name: fnet3d__ipsc_bf_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc__bf/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_paper/ipsc__bf/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc__bf/a549__denv +- name: celldiff_r2_iterative__ipsc_bf_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc__bf/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_r2_iterative/ipsc__bf/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc__bf/a549__mock +- name: fnet3d__ipsc_bf_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc__bf/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_paper/ipsc__bf/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc__bf/a549__mock +- name: celldiff_r2_iterative__ipsc_bf_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc__bf/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_r2_iterative/ipsc__bf/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc__bf/a549__zikv +- name: fnet3d__ipsc_bf_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc__bf/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_paper/ipsc__bf/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc__bf/a549__zikv +- name: celldiff_r2_iterative__ipsc_bf_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc__bf/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/celldiff_r2_iterative/ipsc__bf/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc__bf/ipsc +- name: fnet3d__ipsc_bf_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc__bf/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fnet3d_paper/ipsc__bf/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc__bf/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained/eval_grouped.yaml index e055c7597..576039e5d 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained/eval_grouped.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained/eval_grouped.yaml @@ -18,257 +18,257 @@ conditions: dataset: a549-mantis-sec61b-denv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_celldiff_r2_iterative__sec61b_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/sec61b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_r2_iterative/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_celldiff_r2_iterative_er_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/a549__denv - name: vscyto3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-sec61b-denv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained__sec61b_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/sec61b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto3d_pretrained/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_er_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/a549__denv - name: unext2__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-sec61b-denv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch__sec61b_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/sec61b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto3d_scratch/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unext2_er_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/a549__denv - name: fnet3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-sec61b-denv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fnet3d_paper__sec61b_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fnet3d_paper/sec61b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_paper/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_fnet3d_er_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/a549__denv - name: pix2pix3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-sec61b-denv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_pix2pix3d_unetvit__sec61b_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/pix2pix3d_unetvit/sec61b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix3d_unetvit/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_pix2pix3d_er_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__denv - name: unetvit3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-sec61b-denv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_unetvit3d__sec61b_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/unetvit3d/sec61b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/unetvit3d/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unetvit3d_er_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/a549__denv - name: celldiff_r2_iterative__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-sec61b-mock target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_celldiff_r2_iterative__sec61b_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/sec61b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_r2_iterative/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_celldiff_r2_iterative_er_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/a549__mock - name: vscyto3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-sec61b-mock target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained__sec61b_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/sec61b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto3d_pretrained/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_er_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/a549__mock - name: unext2__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-sec61b-mock target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch__sec61b_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/sec61b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto3d_scratch/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unext2_er_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/a549__mock - name: fnet3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-sec61b-mock target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fnet3d_paper__sec61b_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fnet3d_paper/sec61b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_paper/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_fnet3d_er_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/a549__mock - name: pix2pix3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-sec61b-mock target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_pix2pix3d_unetvit__sec61b_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/pix2pix3d_unetvit/sec61b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix3d_unetvit/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_pix2pix3d_er_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__mock - name: unetvit3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-sec61b-mock target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_unetvit3d__sec61b_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/unetvit3d/sec61b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/unetvit3d/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unetvit3d_er_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/a549__mock - name: celldiff_r2_iterative__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-sec61b-zikv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_celldiff_r2_iterative__sec61b_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/sec61b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_r2_iterative/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_celldiff_r2_iterative_er_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/a549__zikv - name: vscyto3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-sec61b-zikv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained__sec61b_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/sec61b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto3d_pretrained/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_er_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/a549__zikv - name: unext2__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-sec61b-zikv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch__sec61b_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/sec61b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto3d_scratch/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unext2_er_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/a549__zikv - name: fnet3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-sec61b-zikv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fnet3d_paper__sec61b_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fnet3d_paper/sec61b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_paper/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_fnet3d_er_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/a549__zikv - name: pix2pix3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-sec61b-zikv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_pix2pix3d_unetvit__sec61b_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/pix2pix3d_unetvit/sec61b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix3d_unetvit/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_pix2pix3d_er_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__zikv - name: unetvit3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-sec61b-zikv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_unetvit3d__sec61b_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/unetvit3d/sec61b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/unetvit3d/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unetvit3d_er_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/a549__zikv - name: celldiff_r2_denoise__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_celldiff_r2_denoise.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/celldiff_r2_denoise/er_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_denoise/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/celldiff_r2_denoise/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_celldiff_r2_denoise_er + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_denoise/ipsc/ipsc - name: celldiff_r2_iterative__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_celldiff_r2_iterative.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/er_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/celldiff_r2_iterative/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_celldiff_r2_iterative_er + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/ipsc - name: celldiff_r2_sliding_window__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_celldiff_r2_sliding_window.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/celldiff_r2_sliding_window/er_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_sliding_window/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/celldiff_r2_sliding_window/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_celldiff_r2_sliding_window_er + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_sliding_window/ipsc/ipsc - name: vscyto3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_fcmae_vscyto3d_pretrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/er_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fcmae_vscyto3d_pretrained/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_vscyto3d_er + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/ipsc - name: unext2__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_fcmae_vscyto3d_scratch.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/er_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fcmae_vscyto3d_scratch/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_unext2_er + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/ipsc - name: fnet3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_fnet3d_paper.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/fnet3d_paper/er_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fnet3d_paper/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_fnet3d_er + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/ipsc - name: pix2pix3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_pix2pix3d_unetvit.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/pix2pix3d_unetvit/er_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/pix2pix3d_unetvit/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_pix2pix3d_er + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/ipsc - name: unetvit3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_unetvit3d.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/unetvit3d/er_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/unetvit3d/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_unetvit3d_er + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d/eval_grouped.yaml new file mode 100644 index 000000000..244e03f15 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d/eval_grouped.yaml @@ -0,0 +1,282 @@ +# @package _global_ +# Focused sibling of grouped/er_ipsc_trained: ONLY the in-focus 2D conditions -- +# fnet2d + FCMAE-2D (unext2_2d, vscyto2d) + celldiff_2d + pix2pix2d +# x {ipsc, a549 mock/denv/zikv} = 20. +# Condition blocks are copied verbatim from a generate_grouped_eval_configs.py run, +# so they stay byte-identical to what the canonical bucket would emit -- only the +# selection is narrowed. +# +# celldiff_2d was folded in on 2026-08-04, once its predicts finished. It was held +# out until then because the generator's only freshness gate is pred_path.is_dir(), +# which passes on a partially-written store (measured 4813 of 5787 chunk files on a +# live nucleus/celldiff_2d/ipsc/a549__denv). The gate applied by hand instead was a +# per-store chunk count against the fnet2d store for the same organelle/pool/bucket, +# required to match exactly. The complete size is a property of (organelle, bucket), +# not a constant: 4270-4300 on the iPSC buckets and 5211-5787 on the A549 ones, and +# er/a549__denv is the low outlier at 5211 in EVERY pool. That one was confirmed +# against two further fully-evaluated models (both FCMAE-2D arms, also 5211, same 12 +# FOVs) so it is the true size and not a shortfall shared with the reference -- which +# a fnet2d-relative gate cannot see by itself. Plus sacct COMPLETED 0:0 on all 48 +# CELLDiff2D_PRED jobs. +# +# pix2pix2d was folded in on 2026-08-05, once its 48 predicts finished (all COMPLETED +# 0:0). Held out for the same reason, but gated harder than celldiff_2d was: per array, +# the expected chunk count = prod(ceil(shape / chunks)) read analytically from that +# array's own zarr.json, compared against the files actually present. That catches a +# truncated write inside a position without needing a reference family at all, which +# is what a fnet2d-relative count could not do. It is paired with a position-set +# comparison against a family already known complete, because a store missing whole +# FOVs is internally self-consistent and its own metadata can never reveal the gap. +# All 48 passed both checks: 100 positions per iPSC bucket, 12 per A549 bucket, every +# array fully chunked (.tmp/pix2pix2d/verify_predict_stores.py). +# +# Why a sibling instead of folding the 2D models into the canonical bucket: +# 1. The generator sets force_recompute.final_metrics: true, so the canonical +# bucket's already-evaluated 3D conditions would ALL recompute, not cache-skip. +# 2. Fairness. The global pixel metrics (PCC/SSIM/FSC/PSNR/Spectral_PCC), +# MicroMS3IM and the CP regionprops are computed over the FULL 3D volume, +# while per-cell similarity, the deep features (DINOv3/DynaCLR/CellDINO/ +# MorphEm) and instance AP are focus-restricted (pipeline.py). Only the +# focus-restricted families are a fair 2D-vs-3D comparison -- a per-z 2D model +# is penalised by the volume-reconstruction columns for planes it never +# targeted (2d-infocus-vs-models.md 1a). The full-3D columns are still +# computed here as diagnostics; they are NOT publishable as 2D-vs-3D. +# +# force_recompute: every pred_* artifact is forced, plus final_metrics. +# +# Until 2026-09-10 this block was `final_metrics: false`, on the grounds that 16 of +# the 20 conditions were already fully evaluated (verified 2026-08-05) and could +# cache-skip. That is now WRONG and the flag is inverted: an affine bug blanked the +# training data at z_window_size=1 (fixed in VisCy 9640537d), so 4 of the 5 2D +# families -- pix2pix2d, celldiff_2d and both FCMAE-2D arms -- were retrained from +# scratch and ALL 192 2D predictions were regenerated 2026-09-10..14. fnet2d is the +# only family that was never affected (flip-only augmentation). +# +# The prediction stores were rewritten IN PLACE with --overwrite, and the eval caches +# carry no prediction provenance -- nothing in the cache key changes when the pixels +# behind it change. So `final_metrics: true` alone is NOT enough: it would recompute +# the summary while still reading August's cached masks, instances and deep features. +# Every pred_* flag has to be forced for the numbers to reflect the new predictions. +# +# gt_* stays false deliberately. The ground truth did not change, and the GT-side deep +# features are the expensive half of a cold extraction. Do not set force_recompute.all +# -- it forces gt_* too (see _resolve_force in evaluation/pipeline_cache.py). +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: celldiff_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_2d/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/a549__denv +- name: vscyto2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_pretrained/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/a549__denv +- name: unext2_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/a549__denv +- name: fnet2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/a549__denv +- name: pix2pix2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/ipsc/a549__denv +- name: celldiff_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_2d/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/a549__mock +- name: vscyto2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_pretrained/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/a549__mock +- name: unext2_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/a549__mock +- name: fnet2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/a549__mock +- name: pix2pix2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/ipsc/a549__mock +- name: celldiff_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_2d/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/a549__zikv +- name: vscyto2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_pretrained/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/a549__zikv +- name: unext2_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/a549__zikv +- name: fnet2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/a549__zikv +- name: pix2pix2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/ipsc/a549__zikv +- name: celldiff_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/celldiff_2d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/ipsc +- name: vscyto2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fcmae_vscyto2d_pretrained/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/ipsc +- name: unext2_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fcmae_vscyto2d_scratch/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/ipsc +- name: fnet2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fnet2d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/ipsc +- name: pix2pix2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/pix2pix2d_unetvit/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d_focus2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d_focus2d/eval_grouped.yaml new file mode 100644 index 000000000..b9f5d6714 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d_focus2d/eval_grouped.yaml @@ -0,0 +1,265 @@ +# @package _global_ +# 2D benchmark (focus2d.halfwidth=1): every metric on one GT-anchored focus plane per +# FOV/timepoint -- pixel metrics, MicroMS3IM and CP on the plane, deep features and per-cell +# similarity on its 3-plane slab, semantic masks segmented on the slab and scored on its +# plane. The 3D benchmark keeps the full volume in the canonical dirs; this bucket never +# writes there (save_dir re-rooted under +# /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/). Conditions: the 20 of +# er_ipsc_trained__2d (5 2D families x 4 test sets), predictions unchanged. Plane anchor: +# nucleus_area on the GT Nuclei channel for iPSC, phase_midband for A549 (no nuclei). Caches: +# /focus2d_h1/ (GT and pred); CP reference __focus2d_h1. Generated by +# applications/dynacell/experiments/2026-10-07_2d-vs-3d-cost/make_focus2d_buckets.py. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +focus2d: + halfwidth: 1 +segmentation: + focus_anchor: nucleus_area + nuclei_channel_name: Nuclei +conditions: +- name: celldiff_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_2d/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/celldiff_2d/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_pretrained/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_pretrained/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_scratch/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fnet2d/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_2d/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/celldiff_2d/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_pretrained/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_pretrained/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_scratch/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: fnet2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fnet2d/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_2d/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/celldiff_2d/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_pretrained/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_pretrained/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_scratch/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fnet2d/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/celldiff_2d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/celldiff_2d/ipsc/ipsc +- name: vscyto2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fcmae_vscyto2d_pretrained/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_pretrained/ipsc/ipsc +- name: unext2_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fcmae_vscyto2d_scratch/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_scratch/ipsc/ipsc +- name: fnet2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fnet2d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fnet2d/ipsc/ipsc +- name: pix2pix2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/pix2pix2d_unetvit/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d_focusslab3/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d_focusslab3/eval_grouped.yaml new file mode 100644 index 000000000..73fbe4484 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d_focusslab3/eval_grouped.yaml @@ -0,0 +1,542 @@ +# @package _global_ +# 2D benchmark, ER/mito segmentation on the focus plane ("slab3"): the 3 planes centered on +# each FOV's focus plane are segmented as one small volume and only the focus plane of +# the mask is scored (focus2d.halfwidth=1, the 2D-benchmark eval mode). The 3D benchmark keeps +# whole-volume masks in the canonical eval dirs; this bucket never writes there. +# +# Models: the five 2D families from er_ipsc_trained__2d and the 3D models from er_ipsc_trained +# (CELL-Diff3D = the iterative sampler only), x the four test sets. +# Plane anchor: nucleus_area on the GT Nuclei channel for the iPSC test set, +# phase_midband (GT Phase3D) for A549, whose SEC61B/TOMM20 stores carry no nuclei. +# +# Output: save_dir = canonical eval dir re-rooted under /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/. Only mask_metrics.* are +# the product. Feature metrics, MicroMS3IM, FSC and Spectral PCC are off (pixel_metrics.csv +# holds the other focus-plane pixel metrics); masks are not cached (milliseconds per slab). +# Generated by applications/dynacell/experiments/2026-10-06_2d-focus-slab3/make_buckets.py. +target_name: er +compute_feature_metrics: false +compute_microssim: false +use_gpu: true +io: + require_complete_cache: false +pixel_metrics: + fsc: null + spectral_pcc: null +focus2d: + halfwidth: 1 +segmentation: + focus_anchor: nucleus_area + nuclei_channel_name: Nuclei +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +conditions: +- name: celldiff_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_2d/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_pretrained/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_scratch/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet2d/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix2d_unetvit/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_2d/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_pretrained/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_scratch/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: fnet2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet2d/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix2d_unetvit/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_2d/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_pretrained/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_scratch/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet2d/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix2d_unetvit/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_2d/ipsc/ipsc +- name: vscyto2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_pretrained/ipsc/ipsc +- name: unext2_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_scratch/ipsc/ipsc +- name: fnet2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet2d/ipsc/ipsc +- name: pix2pix2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix2d_unetvit/ipsc/ipsc +- name: celldiff_r2_iterative__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_r2_iterative/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: vscyto3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_pretrained/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unext2__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_scratch/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: fnet3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet3d_paper/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix3d_unetvit/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unetvit3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/unetvit3d/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: celldiff_r2_iterative__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_r2_iterative/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: vscyto3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_pretrained/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unext2__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_scratch/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: fnet3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet3d_paper/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix3d_unetvit/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unetvit3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/unetvit3d/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: celldiff_r2_iterative__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_r2_iterative/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: vscyto3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_pretrained/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unext2__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_scratch/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: fnet3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet3d_paper/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix3d_unetvit/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unetvit3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/unetvit3d/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: celldiff_r2_iterative__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_r2_iterative/ipsc/ipsc +- name: vscyto3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_pretrained/ipsc/ipsc +- name: unext2__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_scratch/ipsc/ipsc +- name: fnet3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet3d_paper/ipsc/ipsc +- name: pix2pix3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix3d_unetvit/ipsc/ipsc +- name: unetvit3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/unetvit3d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d_samplematched/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d_samplematched/eval_grouped.yaml new file mode 100644 index 000000000..5c387e5c0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d_samplematched/eval_grouped.yaml @@ -0,0 +1,77 @@ +# @package _global_ +# Focused sibling of grouped/er_ipsc_trained__2d: ONLY the sample-matched +# UNeXt2-2D ablation arm (fcmae_vscyto2d_scratch_samplematched: the 3D fit's +# optimizer budget, 128 samples/step, warmup 8500, 3D cosine horizon) +# x {ipsc, a549 mock/denv/zikv} = 4. +# Condition blocks come from generate_grouped_eval_configs.py's own parse_zarr_name + +# build_leaf_yaml, fed the output_store of each predict leaf in +# er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/ (built by +# experiments/2026-09-29_unext2-2d-samplematched/build_eval_buckets.py). +# +# Top-level settings, including force_recompute, are copied from the __2d sibling so +# the arm is scored exactly as its fcmae_vscyto2d_scratch baseline was. Compare on +# the focus-restricted metrics only; the full-3D columns are diagnostics (see the +# __2d leaf header). +# +# GATE before running: pred_path.is_dir() passes on a half-written store. Require +# sacct COMPLETED 0:0 on all predicts AND per-array chunk counts equal to +# prod(ceil(shape / chunks)) AND the position set equal to the baseline store's. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: unext2_2d_samplematched__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__denv +- name: unext2_2d_samplematched__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__mock +- name: unext2_2d_samplematched__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__zikv +- name: unext2_2d_samplematched__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch_samplematched/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fcmae_vscyto2d_scratch_samplematched/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch_samplematched/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d_voxelmatched/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d_voxelmatched/eval_grouped.yaml new file mode 100644 index 000000000..1e141fa32 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__2d_voxelmatched/eval_grouped.yaml @@ -0,0 +1,76 @@ +# @package _global_ +# Focused sibling of grouped/er_ipsc_trained__2d: ONLY the voxel-matched +# FNet-2D ablation arm (fnet2d_voxelmatched, batch 48 -> 1536 = fnet3d_paper's +# planes/step) x {ipsc, a549 mock/denv/zikv} = 4. +# Condition blocks come from generate_grouped_eval_configs.py's own parse_zarr_name + +# build_leaf_yaml, fed the output_store of each predict leaf in +# er/fnet2d_voxelmatched/ipsc_confocal/ (built by +# experiments/2026-09-24_fnet2d-voxelmatched-smoke/build_eval_buckets.py). +# +# Top-level settings, including force_recompute, are copied from the __2d sibling so +# the arm is scored exactly as its fnet2d baseline was. Compare on the +# focus-restricted metrics only; the full-3D columns are diagnostics (see the __2d +# leaf header). +# +# GATE before running: pred_path.is_dir() passes on a half-written store. Require +# sacct COMPLETED 0:0 on all predicts AND per-array chunk counts equal to +# prod(ceil(shape / chunks)) AND the position set equal to the fnet2d sibling store's. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: fnet2d_voxelmatched__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d_voxelmatched/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d_voxelmatched/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d_voxelmatched/ipsc/a549__denv +- name: fnet2d_voxelmatched__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d_voxelmatched/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d_voxelmatched/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d_voxelmatched/ipsc/a549__mock +- name: fnet2d_voxelmatched__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d_voxelmatched/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d_voxelmatched/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d_voxelmatched/ipsc/a549__zikv +- name: fnet2d_voxelmatched__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d_voxelmatched/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fnet2d_voxelmatched/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d_voxelmatched/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__lite/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__lite/eval_grouped.yaml new file mode 100644 index 000000000..a9d593819 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained__lite/eval_grouped.yaml @@ -0,0 +1,219 @@ +# @package _global_ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_ipsc_trained/eval_grouped.yaml. Do not edit; regenerate. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +compute_microssim: false +feature_metrics: + compute_fid: false + compute_prc: false + compute_mind: false +conditions: +- name: celldiff_r2_iterative__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/celldiff_r2_iterative/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2_iterative/ipsc/a549__denv +- name: vscyto3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/fcmae_vscyto3d_pretrained/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/ipsc/a549__denv +- name: unext2__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/fcmae_vscyto3d_scratch/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/ipsc/a549__denv +- name: fnet3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/fnet3d_paper/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/ipsc/a549__denv +- name: unetvit3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/unetvit3d/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/ipsc/a549__denv +- name: celldiff_r2_iterative__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/celldiff_r2_iterative/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2_iterative/ipsc/a549__mock +- name: vscyto3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/fcmae_vscyto3d_pretrained/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/ipsc/a549__mock +- name: unext2__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/fcmae_vscyto3d_scratch/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/ipsc/a549__mock +- name: fnet3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/fnet3d_paper/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/ipsc/a549__mock +- name: unetvit3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/unetvit3d/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/ipsc/a549__mock +- name: celldiff_r2_iterative__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/celldiff_r2_iterative/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2_iterative/ipsc/a549__zikv +- name: vscyto3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/fcmae_vscyto3d_pretrained/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/ipsc/a549__zikv +- name: unext2__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/fcmae_vscyto3d_scratch/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/ipsc/a549__zikv +- name: fnet3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/fnet3d_paper/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/ipsc/a549__zikv +- name: unetvit3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/unetvit3d/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/ipsc/a549__zikv +- name: celldiff_r2_iterative__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/er/celldiff_r2_iterative/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2_iterative/ipsc/ipsc +- name: vscyto3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/er/fcmae_vscyto3d_pretrained/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/ipsc/ipsc +- name: unext2__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/er/fcmae_vscyto3d_scratch/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/ipsc/ipsc +- name: fnet3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/er/fnet3d_paper/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/ipsc/ipsc +- name: unetvit3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/er/unetvit3d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint/eval_grouped.yaml index 7af51ffc0..70dac050b 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint/eval_grouped.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint/eval_grouped.yaml @@ -1,5 +1,5 @@ # @package _global_ -# Grouped leaf: er bucket, joint models (16 conditions). Auto-generated by tools/generate_grouped_eval_configs.py. +# Grouped leaf: er bucket, joint models (24 conditions). Auto-generated by tools/generate_grouped_eval_configs.py. target_name: er compute_feature_metrics: true use_gpu: true @@ -18,157 +18,237 @@ conditions: dataset: a549-mantis-sec61b-denv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/sec61b_celldiff_r2_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/celldiff_r2/sec61b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_r2/joint/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_er_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/a549__denv - name: vscyto3d__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-sec61b-denv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/sec61b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto3d_pretrained/joint/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_er_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/a549__denv - name: unext2__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-sec61b-denv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_scratch/sec61b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto3d_scratch/joint/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_er_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/a549__denv - name: fnet3d__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-sec61b-denv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fnet3d_paper_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fnet3d_paper/sec61b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_paper/joint/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_er_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/a549__denv +- name: pix2pix3d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix3d_unetvit/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__denv +- name: unetvit3d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/unetvit3d/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/a549__denv - name: celldiff_r2__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-sec61b-mock target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/sec61b_celldiff_r2_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/celldiff_r2/sec61b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_r2/joint/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_er_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/a549__mock - name: vscyto3d__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-sec61b-mock target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/sec61b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto3d_pretrained/joint/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_er_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/a549__mock - name: unext2__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-sec61b-mock target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_scratch/sec61b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto3d_scratch/joint/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_er_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/a549__mock - name: fnet3d__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-sec61b-mock target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fnet3d_paper_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fnet3d_paper/sec61b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_paper/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/a549__mock +- name: pix2pix3d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix3d_unetvit/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__mock +- name: unetvit3d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/unetvit3d/joint/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_er_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/a549__mock - name: celldiff_r2__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-sec61b-zikv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/sec61b_celldiff_r2_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/celldiff_r2/sec61b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_r2/joint/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_er_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/a549__zikv - name: vscyto3d__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-sec61b-zikv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/sec61b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto3d_pretrained/joint/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_er_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/a549__zikv - name: unext2__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-sec61b-zikv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_scratch/sec61b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto3d_scratch/joint/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_er_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/a549__zikv - name: fnet3d__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-sec61b-zikv target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fnet3d_paper_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fnet3d_paper/sec61b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet3d_paper/joint/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_er_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/a549__zikv +- name: pix2pix3d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix3d_unetvit/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__zikv +- name: unetvit3d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/unetvit3d/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/a549__zikv - name: celldiff_r2__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/sec61b_celldiff_r2.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/celldiff_r2/er_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/celldiff_r2/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_er + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/ipsc - name: vscyto3d__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_fcmae_vscyto3d_pretrained_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/er_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fcmae_vscyto3d_pretrained/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_er + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/ipsc - name: unext2__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_fcmae_vscyto3d_scratch_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/fcmae_vscyto3d_scratch/er_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fcmae_vscyto3d_scratch/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_er + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/ipsc - name: fnet3d__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: sec61b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_fnet3d_paper_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/fnet3d_paper/er_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fnet3d_paper/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/ipsc +- name: pix2pix3d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/pix2pix3d_unetvit/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/ipsc +- name: unetvit3d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/unetvit3d/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_er + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint__2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint__2d/eval_grouped.yaml new file mode 100644 index 000000000..545764798 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint__2d/eval_grouped.yaml @@ -0,0 +1,282 @@ +# @package _global_ +# Focused sibling of grouped/er_joint: ONLY the in-focus 2D conditions -- +# fnet2d + FCMAE-2D (unext2_2d, vscyto2d) + celldiff_2d + pix2pix2d +# x {ipsc, a549 mock/denv/zikv} = 20. +# Condition blocks are copied verbatim from a generate_grouped_eval_configs.py run, +# so they stay byte-identical to what the canonical bucket would emit -- only the +# selection is narrowed. +# +# celldiff_2d was folded in on 2026-08-04, once its predicts finished. It was held +# out until then because the generator's only freshness gate is pred_path.is_dir(), +# which passes on a partially-written store (measured 4813 of 5787 chunk files on a +# live nucleus/celldiff_2d/ipsc/a549__denv). The gate applied by hand instead was a +# per-store chunk count against the fnet2d store for the same organelle/pool/bucket, +# required to match exactly. The complete size is a property of (organelle, bucket), +# not a constant: 4270-4300 on the iPSC buckets and 5211-5787 on the A549 ones, and +# er/a549__denv is the low outlier at 5211 in EVERY pool. That one was confirmed +# against two further fully-evaluated models (both FCMAE-2D arms, also 5211, same 12 +# FOVs) so it is the true size and not a shortfall shared with the reference -- which +# a fnet2d-relative gate cannot see by itself. Plus sacct COMPLETED 0:0 on all 48 +# CELLDiff2D_PRED jobs. +# +# pix2pix2d was folded in on 2026-08-05, once its 48 predicts finished (all COMPLETED +# 0:0). Held out for the same reason, but gated harder than celldiff_2d was: per array, +# the expected chunk count = prod(ceil(shape / chunks)) read analytically from that +# array's own zarr.json, compared against the files actually present. That catches a +# truncated write inside a position without needing a reference family at all, which +# is what a fnet2d-relative count could not do. It is paired with a position-set +# comparison against a family already known complete, because a store missing whole +# FOVs is internally self-consistent and its own metadata can never reveal the gap. +# All 48 passed both checks: 100 positions per iPSC bucket, 12 per A549 bucket, every +# array fully chunked (.tmp/pix2pix2d/verify_predict_stores.py). +# +# Why a sibling instead of folding the 2D models into the canonical bucket: +# 1. The generator sets force_recompute.final_metrics: true, so the canonical +# bucket's already-evaluated 3D conditions would ALL recompute, not cache-skip. +# 2. Fairness. The global pixel metrics (PCC/SSIM/FSC/PSNR/Spectral_PCC), +# MicroMS3IM and the CP regionprops are computed over the FULL 3D volume, +# while per-cell similarity, the deep features (DINOv3/DynaCLR/CellDINO/ +# MorphEm) and instance AP are focus-restricted (pipeline.py). Only the +# focus-restricted families are a fair 2D-vs-3D comparison -- a per-z 2D model +# is penalised by the volume-reconstruction columns for planes it never +# targeted (2d-infocus-vs-models.md 1a). The full-3D columns are still +# computed here as diagnostics; they are NOT publishable as 2D-vs-3D. +# +# force_recompute: every pred_* artifact is forced, plus final_metrics. +# +# Until 2026-09-10 this block was `final_metrics: false`, on the grounds that 16 of +# the 20 conditions were already fully evaluated (verified 2026-08-05) and could +# cache-skip. That is now WRONG and the flag is inverted: an affine bug blanked the +# training data at z_window_size=1 (fixed in VisCy 9640537d), so 4 of the 5 2D +# families -- pix2pix2d, celldiff_2d and both FCMAE-2D arms -- were retrained from +# scratch and ALL 192 2D predictions were regenerated 2026-09-10..14. fnet2d is the +# only family that was never affected (flip-only augmentation). +# +# The prediction stores were rewritten IN PLACE with --overwrite, and the eval caches +# carry no prediction provenance -- nothing in the cache key changes when the pixels +# behind it change. So `final_metrics: true` alone is NOT enough: it would recompute +# the summary while still reading August's cached masks, instances and deep features. +# Every pred_* flag has to be forced for the numbers to reflect the new predictions. +# +# gt_* stays false deliberately. The ground truth did not change, and the GT-side deep +# features are the expensive half of a cold extraction. Do not set force_recompute.all +# -- it forces gt_* too (see _resolve_force in evaluation/pipeline_cache.py). +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: celldiff_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_2d/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/a549__denv +- name: vscyto2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_pretrained/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/a549__denv +- name: unext2_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/a549__denv +- name: fnet2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/a549__denv +- name: pix2pix2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/a549__denv +- name: celldiff_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_2d/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/a549__mock +- name: vscyto2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_pretrained/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/a549__mock +- name: unext2_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/a549__mock +- name: fnet2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/a549__mock +- name: pix2pix2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/a549__mock +- name: celldiff_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_2d/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/a549__zikv +- name: vscyto2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_pretrained/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/a549__zikv +- name: unext2_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/a549__zikv +- name: fnet2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/a549__zikv +- name: pix2pix2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/a549__zikv +- name: celldiff_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/celldiff_2d/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/ipsc +- name: vscyto2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fcmae_vscyto2d_pretrained/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/ipsc +- name: unext2_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fcmae_vscyto2d_scratch/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/ipsc +- name: fnet2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fnet2d/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/ipsc +- name: pix2pix2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/pix2pix2d_unetvit/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint__2d_focus2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint__2d_focus2d/eval_grouped.yaml new file mode 100644 index 000000000..9e1b1528a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint__2d_focus2d/eval_grouped.yaml @@ -0,0 +1,265 @@ +# @package _global_ +# 2D benchmark (focus2d.halfwidth=1): every metric on one GT-anchored focus plane per +# FOV/timepoint -- pixel metrics, MicroMS3IM and CP on the plane, deep features and per-cell +# similarity on its 3-plane slab, semantic masks segmented on the slab and scored on its +# plane. The 3D benchmark keeps the full volume in the canonical dirs; this bucket never +# writes there (save_dir re-rooted under +# /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/). Conditions: the 20 of +# er_joint__2d (5 2D families x 4 test sets), predictions unchanged. Plane anchor: +# nucleus_area on the GT Nuclei channel for iPSC, phase_midband for A549 (no nuclei). Caches: +# /focus2d_h1/ (GT and pred); CP reference __focus2d_h1. Generated by +# applications/dynacell/experiments/2026-10-07_2d-vs-3d-cost/make_focus2d_buckets.py. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +focus2d: + halfwidth: 1 +segmentation: + focus_anchor: nucleus_area + nuclei_channel_name: Nuclei +conditions: +- name: celldiff_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_2d/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/celldiff_2d/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_pretrained/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_pretrained/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_scratch/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fnet2d/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_2d/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/celldiff_2d/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_pretrained/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_pretrained/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_scratch/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: fnet2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fnet2d/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/celldiff_2d/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/celldiff_2d/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_pretrained/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_pretrained/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fcmae_vscyto2d_scratch/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_scratch/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/fnet2d/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fnet2d/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix2d_unetvit/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/celldiff_2d/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/celldiff_2d/joint/ipsc +- name: vscyto2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fcmae_vscyto2d_pretrained/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_pretrained/joint/ipsc +- name: unext2_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fcmae_vscyto2d_scratch/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fcmae_vscyto2d_scratch/joint/ipsc +- name: fnet2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/fnet2d/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/fnet2d/joint/ipsc +- name: pix2pix2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/pix2pix2d_unetvit/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/er/pix2pix2d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint__2d_focusslab3/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint__2d_focusslab3/eval_grouped.yaml new file mode 100644 index 000000000..285e8fa2b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint__2d_focusslab3/eval_grouped.yaml @@ -0,0 +1,542 @@ +# @package _global_ +# 2D benchmark, ER/mito segmentation on the focus plane ("slab3"): the 3 planes centered on +# each FOV's focus plane are segmented as one small volume and only the focus plane of +# the mask is scored (focus2d.halfwidth=1, the 2D-benchmark eval mode). The 3D benchmark keeps +# whole-volume masks in the canonical eval dirs; this bucket never writes there. +# +# Models: the five 2D families from er_joint__2d and the 3D models from er_joint +# (CELL-Diff3D = the iterative sampler only), x the four test sets. +# Plane anchor: nucleus_area on the GT Nuclei channel for the iPSC test set, +# phase_midband (GT Phase3D) for A549, whose SEC61B/TOMM20 stores carry no nuclei. +# +# Output: save_dir = canonical eval dir re-rooted under /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/. Only mask_metrics.* are +# the product. Feature metrics, MicroMS3IM, FSC and Spectral PCC are off (pixel_metrics.csv +# holds the other focus-plane pixel metrics); masks are not cached (milliseconds per slab). +# Generated by applications/dynacell/experiments/2026-10-06_2d-focus-slab3/make_buckets.py. +target_name: er +compute_feature_metrics: false +compute_microssim: false +use_gpu: true +io: + require_complete_cache: false +pixel_metrics: + fsc: null + spectral_pcc: null +focus2d: + halfwidth: 1 +segmentation: + focus_anchor: nucleus_area + nuclei_channel_name: Nuclei +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +conditions: +- name: celldiff_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_2d/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_pretrained/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_scratch/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet2d/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix2d_unetvit/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_2d/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_pretrained/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_scratch/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: fnet2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet2d/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix2d_unetvit/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_2d/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_pretrained/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_scratch/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet2d/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix2d_unetvit/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_2d/joint/ipsc +- name: vscyto2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_pretrained/joint/ipsc +- name: unext2_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto2d_scratch/joint/ipsc +- name: fnet2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet2d/joint/ipsc +- name: pix2pix2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix2d_unetvit/joint/ipsc +- name: celldiff_r2__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_r2/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: vscyto3d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_pretrained/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unext2__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_scratch/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: fnet3d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet3d_paper/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix3d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix3d_unetvit/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unetvit3d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/unetvit3d/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: celldiff_r2__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_r2/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: vscyto3d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_pretrained/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unext2__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_scratch/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: fnet3d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet3d_paper/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix3d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix3d_unetvit/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unetvit3d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/unetvit3d/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: celldiff_r2__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_r2/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: vscyto3d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_pretrained/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unext2__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_scratch/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: fnet3d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet3d_paper/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix3d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix3d_unetvit/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unetvit3d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/unetvit3d/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: celldiff_r2__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/celldiff_r2/joint/ipsc +- name: vscyto3d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_pretrained/joint/ipsc +- name: unext2__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fcmae_vscyto3d_scratch/joint/ipsc +- name: fnet3d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/fnet3d_paper/joint/ipsc +- name: pix2pix3d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/pix2pix3d_unetvit/joint/ipsc +- name: unetvit3d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/er/unetvit3d/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint__lite/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint__lite/eval_grouped.yaml new file mode 100644 index 000000000..d2e8cf071 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint__lite/eval_grouped.yaml @@ -0,0 +1,59 @@ +# @package _global_ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_joint/eval_grouped.yaml. Do not edit; regenerate. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +compute_microssim: false +feature_metrics: + compute_fid: false + compute_prc: false + compute_mind: false +conditions: +- name: celldiff_r2__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/celldiff_r2/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/joint/a549__denv +- name: celldiff_r2__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/celldiff_r2/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/joint/a549__mock +- name: celldiff_r2__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/er/celldiff_r2/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/joint/a549__zikv +- name: celldiff_r2__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/er/celldiff_r2/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_phase_floor__2d_focus2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_phase_floor__2d_focus2d/eval_grouped.yaml new file mode 100644 index 000000000..0841c799e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_phase_floor__2d_focus2d/eval_grouped.yaml @@ -0,0 +1,74 @@ +# @package _global_ +# 2D benchmark (focus2d.halfwidth=1): every metric on one GT-anchored focus plane per +# FOV/timepoint -- pixel metrics, MicroMS3IM and CP on the plane, deep features and per-cell +# similarity on its 3-plane slab, semantic masks segmented on the slab and scored on its +# plane. The 3D benchmark keeps the full volume in the canonical dirs; this bucket never +# writes there (save_dir re-rooted under +# /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/). Phase floor: the raw +# Phase3D input scored as the prediction (io.pred_is_source) on the same planes. Plane anchor: +# nucleus_area on the GT Nuclei channel for iPSC, phase_midband for A549 (no nuclei). Caches: +# /focus2d_h1/ (GT and pred); CP reference __focus2d_h1. Generated by +# applications/dynacell/experiments/2026-10-07_2d-vs-3d-cost/make_focus2d_buckets.py. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +focus2d: + halfwidth: 1 +segmentation: + focus_anchor: nucleus_area + nuclei_channel_name: Nuclei +conditions: +- name: phase__no_model__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/a549/evaluations_with_embeddings/eval_phase_er_denv + segmentation: + focus_anchor: phase_midband +- name: phase__no_model__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/a549/evaluations_with_embeddings/eval_phase_er_mock + segmentation: + focus_anchor: phase_midband +- name: phase__no_model__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/a549/evaluations_with_embeddings/eval_phase_er_zikv + segmentation: + focus_anchor: phase_midband +- name: phase__no_model__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/ipsc/evaluations_with_embeddings/eval_phase_er diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_phase_floor__2d_focusslab3/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_phase_floor__2d_focusslab3/eval_grouped.yaml new file mode 100644 index 000000000..43da741cb --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/er_phase_floor__2d_focusslab3/eval_grouped.yaml @@ -0,0 +1,74 @@ +# @package _global_ +# Phase floor for the 2D-benchmark slab3 ER/mito buckets (er_*__2d_focusslab3): the raw +# Phase3D input scored as the "prediction" (io.pred_is_source) on the same focus plane, with +# the same slab3 recipe and plane anchors. It is the no-model reference those focus-plane +# Dice values are compared against; the whole-volume floor stays in the canonical +# evaluations_with_embeddings/eval_phase_* dirs, re-rooted here under /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/. +# Generated by applications/dynacell/experiments/2026-10-06_2d-focus-slab3/make_floor_buckets.py. +target_name: er +compute_feature_metrics: false +compute_microssim: false +use_gpu: true +io: + require_complete_cache: false +pixel_metrics: + fsc: null + spectral_pcc: null +focus2d: + halfwidth: 1 +segmentation: + focus_anchor: nucleus_area + nuclei_channel_name: Nuclei +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +conditions: +- name: phase__no_model__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/ipsc/evaluations_with_embeddings/eval_phase_er +- name: phase__no_model__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/a549/evaluations_with_embeddings/eval_phase_er_mock + segmentation: + focus_anchor: phase_midband +- name: phase__no_model__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/a549/evaluations_with_embeddings/eval_phase_er_denv + segmentation: + focus_anchor: phase_midband +- name: phase__no_model__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/a549/evaluations_with_embeddings/eval_phase_er_zikv + segmentation: + focus_anchor: phase_midband diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane__2d_focus2d_pix2pix2d_wmatch/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane__2d_focus2d_pix2pix2d_wmatch/eval_grouped.yaml new file mode 100644 index 000000000..826da921c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane__2d_focus2d_pix2pix2d_wmatch/eval_grouped.yaml @@ -0,0 +1,202 @@ +# @package _global_ +# pix2pix2d warmup-matched refit: the pix2pix2d conditions of the membrane +# 2D focus2d buckets (and seed1 bucket), on the pix2pix2d_unetvit_wmatch[_seed1] stores. +# Same recipe, planes and caches as those buckets. Written by +# applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +focus2d: + halfwidth: 1 +conditions: +- name: pix2pix2d_wmatch__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit_wmatch/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_wmatch/ipsc/a549__denv +- name: pix2pix2d_wmatch__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit_wmatch/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_wmatch/ipsc/a549__mock +- name: pix2pix2d_wmatch__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv +- name: pix2pix2d_wmatch__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/pix2pix2d_unetvit_wmatch/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_wmatch/ipsc/ipsc +- name: pix2pix2d_wmatch__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit_wmatch/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_wmatch/a549/a549__denv +- name: pix2pix2d_wmatch__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit_wmatch/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_wmatch/a549/a549__mock +- name: pix2pix2d_wmatch__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit_wmatch/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_wmatch/a549/a549__zikv +- name: pix2pix2d_wmatch__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/pix2pix2d_unetvit_wmatch/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_wmatch/a549/ipsc +- name: pix2pix2d_wmatch__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit_wmatch/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_wmatch/joint/a549__denv +- name: pix2pix2d_wmatch__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit_wmatch/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_wmatch/joint/a549__mock +- name: pix2pix2d_wmatch__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit_wmatch/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_wmatch/joint/a549__zikv +- name: pix2pix2d_wmatch__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/pix2pix2d_unetvit_wmatch/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_wmatch/joint/ipsc +- name: pix2pix2d_wmatch_seed1__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__denv +- name: pix2pix2d_wmatch_seed1__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__mock +- name: pix2pix2d_wmatch_seed1__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__zikv +- name: pix2pix2d_wmatch_seed1__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained/eval_grouped.yaml index b0ee396c8..10f39fdac 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained/eval_grouped.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained/eval_grouped.yaml @@ -13,10 +13,8 @@ force_recompute: final_metrics: true compute_instance_ap: true segmentation: - backend: cellpose_watershed + backend: cpdino nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: false conditions: - name: celldiff_r2__a549_trained__a549_denv benchmark: @@ -24,212 +22,212 @@ conditions: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/celldiff_r2/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_r2/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/a549__denv - name: vscyto3d__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/a549__denv - name: unext2__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/a549__denv - name: fnet3d__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fnet3d_paper/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet3d_paper/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/a549__denv - name: pix2pix3d__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit_a549trained__caax_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/pix2pix3d_unetvit/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix3d_unetvit/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_pix2pix3d_a549trained_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__denv - name: celldiff_r2__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/celldiff_r2/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_r2/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/a549__mock - name: vscyto3d__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/a549__mock - name: unext2__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/a549__mock - name: fnet3d__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fnet3d_paper/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet3d_paper/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/a549__mock - name: pix2pix3d__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit_a549trained__caax_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/pix2pix3d_unetvit/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix3d_unetvit/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_pix2pix3d_a549trained_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__mock - name: celldiff_r2__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/celldiff_r2/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_r2/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/a549__zikv - name: vscyto3d__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/a549__zikv - name: unext2__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/a549__zikv - name: fnet3d__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fnet3d_paper/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet3d_paper/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/a549__zikv - name: pix2pix3d__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit_a549trained__caax_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/pix2pix3d_unetvit/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix3d_unetvit/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_pix2pix3d_a549trained_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__zikv - name: celldiff_r2__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_celldiff_r2_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/celldiff_r2/membrane_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/celldiff_r2/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/ipsc - name: vscyto3d__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fcmae_vscyto3d_pretrained_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/membrane_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/ipsc - name: unext2__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fcmae_vscyto3d_scratch_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/membrane_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/ipsc - name: fnet3d__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fnet3d_paper_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/fnet3d_paper/membrane_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fnet3d_paper/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/ipsc - name: pix2pix3d__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_pix2pix3d_unetvit_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/pix2pix3d_unetvit/membrane_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/pix2pix3d_unetvit/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_pix2pix3d_a549trained_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained__2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained__2d/eval_grouped.yaml new file mode 100644 index 000000000..492d7e62f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained__2d/eval_grouped.yaml @@ -0,0 +1,301 @@ +# @package _global_ +# Focused sibling of grouped/membrane_a549_trained: ONLY the in-focus 2D conditions -- +# fnet2d + FCMAE-2D (unext2_2d, vscyto2d) + celldiff_2d + pix2pix2d +# x {ipsc, a549 mock/denv/zikv} = 20. +# Condition blocks are copied verbatim from a generate_grouped_eval_configs.py run, +# so they stay byte-identical to what the canonical bucket would emit -- only the +# selection is narrowed. +# +# celldiff_2d was folded in on 2026-08-04, once its predicts finished. It was held +# out until then because the generator's only freshness gate is pred_path.is_dir(), +# which passes on a partially-written store (measured 4813 of 5787 chunk files on a +# live nucleus/celldiff_2d/ipsc/a549__denv). The gate applied by hand instead was a +# per-store chunk count against the fnet2d store for the same organelle/pool/bucket, +# required to match exactly. The complete size is a property of (organelle, bucket), +# not a constant: 4270-4300 on the iPSC buckets and 5211-5787 on the A549 ones, and +# er/a549__denv is the low outlier at 5211 in EVERY pool. That one was confirmed +# against two further fully-evaluated models (both FCMAE-2D arms, also 5211, same 12 +# FOVs) so it is the true size and not a shortfall shared with the reference -- which +# a fnet2d-relative gate cannot see by itself. Plus sacct COMPLETED 0:0 on all 48 +# CELLDiff2D_PRED jobs. +# +# pix2pix2d was folded in on 2026-08-05, once its 48 predicts finished (all COMPLETED +# 0:0). Held out for the same reason, but gated harder than celldiff_2d was: per array, +# the expected chunk count = prod(ceil(shape / chunks)) read analytically from that +# array's own zarr.json, compared against the files actually present. That catches a +# truncated write inside a position without needing a reference family at all, which +# is what a fnet2d-relative count could not do. It is paired with a position-set +# comparison against a family already known complete, because a store missing whole +# FOVs is internally self-consistent and its own metadata can never reveal the gap. +# All 48 passed both checks: 100 positions per iPSC bucket, 12 per A549 bucket, every +# array fully chunked (.tmp/pix2pix2d/verify_predict_stores.py). +# +# Why a sibling instead of folding the 2D models into the canonical bucket: +# 1. The generator sets force_recompute.final_metrics: true, so the canonical +# bucket's already-evaluated 3D conditions would ALL recompute, not cache-skip. +# 2. Fairness. The global pixel metrics (PCC/SSIM/FSC/PSNR/Spectral_PCC), +# MicroMS3IM and the CP regionprops are computed over the FULL 3D volume, +# while per-cell similarity, the deep features (DINOv3/DynaCLR/CellDINO/ +# MorphEm) and instance AP are focus-restricted (pipeline.py). Only the +# focus-restricted families are a fair 2D-vs-3D comparison -- a per-z 2D model +# is penalised by the volume-reconstruction columns for planes it never +# targeted (2d-infocus-vs-models.md 1a). The full-3D columns are still +# computed here as diagnostics; they are NOT publishable as 2D-vs-3D. +# +# force_recompute: every pred_* artifact is forced, plus final_metrics. +# +# Until 2026-09-10 this block was `final_metrics: false`, on the grounds that 16 of +# the 20 conditions were already fully evaluated (verified 2026-08-05) and could +# cache-skip. That is now WRONG and the flag is inverted: an affine bug blanked the +# training data at z_window_size=1 (fixed in VisCy 9640537d), so 4 of the 5 2D +# families -- pix2pix2d, celldiff_2d and both FCMAE-2D arms -- were retrained from +# scratch and ALL 192 2D predictions were regenerated 2026-09-10..14. fnet2d is the +# only family that was never affected (flip-only augmentation). +# +# The prediction stores were rewritten IN PLACE with --overwrite, and the eval caches +# carry no prediction provenance -- nothing in the cache key changes when the pixels +# behind it change. So `final_metrics: true` alone is NOT enough: it would recompute +# the summary while still reading August's cached masks, instances and deep features. +# Every pred_* flag has to be forced for the numbers to reflect the new predictions. +# +# gt_* stays false deliberately. The ground truth did not change, and the GT-side deep +# features are the expensive half of a cold extraction. Do not set force_recompute.all +# -- it forces gt_* too (see _resolve_force in evaluation/pipeline_cache.py). +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +conditions: +- name: celldiff_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/a549__denv +- name: vscyto2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/a549__denv +- name: unext2_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/a549__denv +- name: fnet2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__denv +- name: pix2pix2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/a549__denv +- name: celldiff_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/a549__mock +- name: vscyto2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/a549__mock +- name: unext2_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/a549__mock +- name: fnet2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__mock +- name: pix2pix2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/a549__mock +- name: celldiff_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/a549__zikv +- name: vscyto2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/a549__zikv +- name: unext2_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/a549__zikv +- name: fnet2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__zikv +- name: pix2pix2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/a549__zikv +- name: celldiff_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/celldiff_2d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/ipsc +- name: vscyto2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/ipsc +- name: unext2_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/ipsc +- name: fnet2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fnet2d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/ipsc +- name: pix2pix2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/pix2pix2d_unetvit/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained__2d_focus2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained__2d_focus2d/eval_grouped.yaml new file mode 100644 index 000000000..073167570 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained__2d_focus2d/eval_grouped.yaml @@ -0,0 +1,251 @@ +# @package _global_ +# 2D benchmark (focus2d.halfwidth=1): every metric on one GT-anchored focus plane per +# FOV/timepoint -- pixel metrics, MicroMS3IM and CP on the plane, deep features and per-cell +# similarity on its 3-plane slab, whole-cell instance masks (cpdino) on the slab MIP. The 3D +# benchmark keeps the full volume in the canonical dirs; this bucket never writes there +# (save_dir re-rooted under +# /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/). Conditions: the 20 of +# membrane_a549_trained__2d (5 2D families x 4 test sets), predictions unchanged. Plane +# anchor: nucleus_area on the GT Nuclei channel (iPSC and A549). Caches: +# /focus2d_h1/ (GT and pred); CP reference __focus2d_h1. Generated by +# applications/dynacell/experiments/2026-10-07_2d-vs-3d-cost/make_focus2d_buckets.py. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +focus2d: + halfwidth: 1 +conditions: +- name: celldiff_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/celldiff_2d/a549/a549__denv +- name: vscyto2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_pretrained/a549/a549__denv +- name: unext2_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_scratch/a549/a549__denv +- name: fnet2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fnet2d/a549/a549__denv +- name: pix2pix2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit/a549/a549__denv +- name: celldiff_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/celldiff_2d/a549/a549__mock +- name: vscyto2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_pretrained/a549/a549__mock +- name: unext2_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_scratch/a549/a549__mock +- name: fnet2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fnet2d/a549/a549__mock +- name: pix2pix2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit/a549/a549__mock +- name: celldiff_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/celldiff_2d/a549/a549__zikv +- name: vscyto2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_pretrained/a549/a549__zikv +- name: unext2_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_scratch/a549/a549__zikv +- name: fnet2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fnet2d/a549/a549__zikv +- name: pix2pix2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit/a549/a549__zikv +- name: celldiff_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/celldiff_2d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/celldiff_2d/a549/ipsc +- name: vscyto2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_pretrained/a549/ipsc +- name: unext2_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_scratch/a549/ipsc +- name: fnet2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fnet2d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fnet2d/a549/ipsc +- name: pix2pix2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/pix2pix2d_unetvit/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained__lite/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained__lite/eval_grouped.yaml new file mode 100644 index 000000000..f2b8389b2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained__lite/eval_grouped.yaml @@ -0,0 +1,183 @@ +# @package _global_ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained/eval_grouped.yaml. Do not edit; regenerate. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +compute_microssim: false +feature_metrics: + compute_fid: false + compute_prc: false + compute_mind: false +conditions: +- name: celldiff_r2__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/celldiff_r2/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/a549/a549__denv +- name: vscyto3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/a549/a549__denv +- name: unext2__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/a549/a549__denv +- name: fnet3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/fnet3d_paper/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/a549/a549__denv +- name: celldiff_r2__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/celldiff_r2/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/a549/a549__mock +- name: vscyto3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/a549/a549__mock +- name: unext2__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/a549/a549__mock +- name: fnet3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/fnet3d_paper/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/a549/a549__mock +- name: celldiff_r2__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/celldiff_r2/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/a549/a549__zikv +- name: vscyto3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/a549/a549__zikv +- name: unext2__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/a549/a549__zikv +- name: fnet3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/fnet3d_paper/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/a549/a549__zikv +- name: celldiff_r2__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/membrane/celldiff_r2/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/a549/ipsc +- name: vscyto3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/a549/ipsc +- name: unext2__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/a549/ipsc +- name: fnet3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/membrane/fnet3d_paper/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained_carved/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained_carved/eval_grouped.yaml deleted file mode 100644 index 0572e560b..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_a549_trained_carved/eval_grouped.yaml +++ /dev/null @@ -1,237 +0,0 @@ -# @package _global_ -# CARVED variant (segmentation.watershed.subtract_nuclei=true) of membrane_a549_trained. -# Secondary cytoplasm-boundary-fidelity metric; no-carve is the headline. -# Generated by tools/make_carved_membrane_leaves.py from membrane_a549_trained/eval_grouped.yaml. -target_name: membrane -compute_feature_metrics: true -use_gpu: true -io: - require_complete_cache: false -runtime: - executor: serial - fov_workers: 1 - threads_per_worker: auto -force_recompute: - final_metrics: true -compute_instance_ap: true -segmentation: - backend: cellpose_watershed - nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: true -conditions: -- name: celldiff_r2__a549_trained__a549_denv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-denv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/celldiff_r2/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_membrane_denv_carved -- name: vscyto3d__a549_trained__a549_denv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-denv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_membrane_denv_carved -- name: unext2__a549_trained__a549_denv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-denv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_membrane_denv_carved -- name: fnet3d__a549_trained__a549_denv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-denv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fnet3d_paper/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_membrane_denv_carved -- name: pix2pix3d__a549_trained__a549_denv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-denv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit_a549trained__caax_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/pix2pix3d_unetvit/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_pix2pix3d_a549trained_membrane_denv_carved -- name: celldiff_r2__a549_trained__a549_mock - benchmark: - dataset_ref: - dataset: a549-mantis-caax-mock - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/celldiff_r2/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_membrane_mock_carved -- name: vscyto3d__a549_trained__a549_mock - benchmark: - dataset_ref: - dataset: a549-mantis-caax-mock - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_membrane_mock_carved -- name: unext2__a549_trained__a549_mock - benchmark: - dataset_ref: - dataset: a549-mantis-caax-mock - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_membrane_mock_carved -- name: fnet3d__a549_trained__a549_mock - benchmark: - dataset_ref: - dataset: a549-mantis-caax-mock - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fnet3d_paper/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_membrane_mock_carved -- name: pix2pix3d__a549_trained__a549_mock - benchmark: - dataset_ref: - dataset: a549-mantis-caax-mock - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit_a549trained__caax_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/pix2pix3d_unetvit/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_pix2pix3d_a549trained_membrane_mock_carved -- name: celldiff_r2__a549_trained__a549_zikv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-zikv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/celldiff_r2/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_membrane_zikv_carved -- name: vscyto3d__a549_trained__a549_zikv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-zikv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_membrane_zikv_carved -- name: unext2__a549_trained__a549_zikv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-zikv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_membrane_zikv_carved -- name: fnet3d__a549_trained__a549_zikv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-zikv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fnet3d_paper/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_membrane_zikv_carved -- name: pix2pix3d__a549_trained__a549_zikv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-zikv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit_a549trained__caax_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/pix2pix3d_unetvit/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_pix2pix3d_a549trained_membrane_zikv_carved -- name: celldiff_r2__a549_trained__ipsc - benchmark: - dataset_ref: - dataset: aics-hipsc - target: membrane - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_celldiff_r2_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/celldiff_r2/membrane_ipsc - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_membrane_carved -- name: vscyto3d__a549_trained__ipsc - benchmark: - dataset_ref: - dataset: aics-hipsc - target: membrane - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fcmae_vscyto3d_pretrained_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/membrane_ipsc - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_membrane_carved -- name: unext2__a549_trained__ipsc - benchmark: - dataset_ref: - dataset: aics-hipsc - target: membrane - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fcmae_vscyto3d_scratch_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/membrane_ipsc - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_membrane_carved -- name: fnet3d__a549_trained__ipsc - benchmark: - dataset_ref: - dataset: aics-hipsc - target: membrane - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fnet3d_paper_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/fnet3d_paper/membrane_ipsc - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_membrane_carved -- name: pix2pix3d__a549_trained__ipsc - benchmark: - dataset_ref: - dataset: aics-hipsc - target: membrane - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_pix2pix3d_unetvit_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/pix2pix3d_unetvit/membrane_ipsc - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_pix2pix3d_a549trained_membrane_carved diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_hek_a549xy/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_hek_a549xy/eval_grouped.yaml new file mode 100644 index 000000000..f32c7f2ee --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_hek_a549xy/eval_grouped.yaml @@ -0,0 +1,152 @@ +# @package _global_ +# Grouped leaf: HEK293T membrane (KRAS) third-cell-type probe, a549xy geometry. +# NeurIPS response item O — the cell-type axis at fixed instrument (both HEK and +# A549 are mantis; iPSC is confocal), so a drop here that A549 does not show is +# cell type rather than microscope. +# +# Hand-written, NOT emitted by tools/generate_grouped_eval_configs.py: that +# generator buckets by (organelle, train_set) with no test-set axis, so it cannot +# express a HEK bucket, and re-running it would rewrite the twelve committed +# ipsc/a549 buckets with the in-flight 2D campaign's fnet2d conditions. +# +# Six model conditions: the paper's regression pair (FNet3D, VSCyto3D) x three +# training pools. CELL-Diff lives in the sibling membrane_hek_a549xy_celldiff +# leaf — its predicts are ~25x slower, and splitting keeps this bucket off that +# tail while both share one warm GT cache. +# +# Carve seeds are PREDICTED, not ground truth, and that is the one real +# departure from the ipsc/a549 membrane buckets. Those carve a GT nucleus +# channel (iPSC cell.zarr Nuclei; A549 the sibling H2B_*.ozx). The HEK release +# ships no nucleus channel -- its nucleus target failed QC -- so the seeds come +# from `Nuclei_prediction` in +# hek/predictions/dual_nucl_memb_fcmae_vscyto3d_pretrained_cytoland_a549xy.zarr, +# a Phase3D->nucleus prediction from the public VSCyto3D (cytoland) checkpoint +# (_dual_nucl_memb/fcmae_vscyto3d_pretrained/_no_train_cytoland/predict__hek_mantis_kras_a549xy.yml). +# Consequences to keep in view when reading this bucket's Dice/IoU/AP: +# * The carve inherits the seed model's error, so HEK whole-cell numbers carry +# one error source the ipsc/a549 rows do not. Treat a HEK-vs-A549 delta as +# including it; do not read it as a pure cell-type effect. +# * The seeds enter twice, not once: the resolved base sets +# slice_selection=focus with focus_anchor=nucleus_area, so the predicted +# nuclei also pick the 2-D instance plane (pipeline.py `_gt_nuclei` feeds +# resolve_focus_instance_planes for a membrane target). Self-consistent -- +# GT, prediction and seeds all land on the same z -- but it means a seed-model +# failure shifts the plane as well as the carve. +# * The seed model is public cytoland weights -- never fine-tuned on dynacell +# and never exposed to HEK -- so it cannot leak a benchmarked checkpoint into +# its own evaluation. Every condition below carves the SAME seed stack, so +# the carve is a constant across the arms being compared. +# What this buys: compute_instance_ap IS pipeline.py's ``instance_mode``, and +# that flag switches what Dice/IoU/Precision/Recall are computed ON. True (here, +# and in the ipsc/a549 membrane buckets) means binarized carved cpdino +# WHOLE-CELL labels -- filled cells, ~30-50% foreground. False (this bucket +# until now) meant SuperModel semantic membrane shells at ~2-5% foreground, +# where a 1-2 voxel displacement alone drops Dice near zero. Those two are not +# comparable, which is why this bucket previously had to omit membrane Dice from +# every cross-cell-type table. It is now on the same footing as the paper's. +# +# Other deliberate departure: +# * cross_condition_probe disabled: it classifies infected-vs-mock, and HEK +# has a single (uninfected) condition. It is default-on whenever feature +# metrics run, and would otherwise log a skip every time. +# +# io.gt_path / gt_channel_name / cell_segmentation_path / gt_cache_dir and +# pixel_metrics.spacing all come from the manifest via benchmark.dataset_ref. +# focus.* is left at the eval.yaml defaults ON PURPOSE: lambda_ill 0.450 is what +# the HEK stores' focus_slice zattrs were written with, and focus.estimator_sig +# is hashed into every deep-feature preprocess_version, so raising it to the +# acquisition's 0.5 would silently discard all four prewarmed embedding caches. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei_prediction +cross_condition_probe: + enabled: false +io: + require_complete_cache: false + # Shared across every condition (unlike the A549 buckets, whose H2B seed store + # varies per plate condition) -- HEK is a single uninfected condition. + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/hek/predictions/dual_nucl_memb_fcmae_vscyto3d_pretrained_cytoland_a549xy.zarr +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +conditions: +- name: fnet3d__ipsc_trained__hek + benchmark: + dataset_ref: + dataset: hek-mantis-kras-a549xy + target: kras + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/membrane/fnet3d_paper/ipsc/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/hek__a549xy +- name: fnet3d__a549_trained__hek + benchmark: + dataset_ref: + dataset: hek-mantis-kras-a549xy + target: kras + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/membrane/fnet3d_paper/a549/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/hek__a549xy +- name: fnet3d__joint__hek + benchmark: + dataset_ref: + dataset: hek-mantis-kras-a549xy + target: kras + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/membrane/fnet3d_paper/joint/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/hek__a549xy +- name: vscyto3d__ipsc_trained__hek + benchmark: + dataset_ref: + dataset: hek-mantis-kras-a549xy + target: kras + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/ipsc/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/hek__a549xy +- name: vscyto3d__a549_trained__hek + benchmark: + dataset_ref: + dataset: hek-mantis-kras-a549xy + target: kras + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/a549/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/hek__a549xy +- name: vscyto3d__joint__hek + benchmark: + dataset_ref: + dataset: hek-mantis-kras-a549xy + target: kras + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/joint/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/hek__a549xy +# No-model floor, last so a failure here cannot cost the six model rows. Sets no +# pred_path: io.pred_is_source makes _ref_hook read the manifest source channel +# (Phase3D) as the prediction and default pred_path to the GT store, so positions +# match by construction. Matches the mito/er phase leaves (no pred_cache_dir). +- name: phase__no_model__hek + benchmark: + dataset_ref: + dataset: hek-mantis-kras-a549xy + target: kras + io: + pred_is_source: true + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/hek/evaluations_with_embeddings/eval_phase_membrane_a549xy diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_hek_a549xy_celldiff/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_hek_a549xy_celldiff/eval_grouped.yaml new file mode 100644 index 000000000..b7c9b180c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_hek_a549xy_celldiff/eval_grouped.yaml @@ -0,0 +1,66 @@ +# @package _global_ +# Grouped leaf: CELL-Diff arm of the HEK293T membrane (KRAS) probe, a549xy geometry. +# +# Split out of membrane_hek_a549xy so the six regression rows are not gated behind +# CELL-Diff's predicts, which are ~25x slower per FOV (iterative flow matching, +# one full-depth window per FOV). Both leaves read the same manifest gt_cache_dir, +# so whichever runs second finds the GT features already warm and only pays for +# its own prediction side. Every option below matches the sibling exactly — the +# rows must be comparable. +# +# Path tokens differ by training pool, which is a CELL-Diff convention rather than +# a checkpoint difference: iPSC-trained writes under celldiff_r2_iterative, A549- +# and joint-trained under celldiff_r2. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +# Carved cpdino whole-cell, seeded by a PREDICTED nucleus channel (the HEK release +# ships none). Rationale, caveats and the seed provenance live in the sibling +# membrane_hek_a549xy/eval_grouped.yaml — keep these four settings in lockstep +# with it or the rows stop being comparable. +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei_prediction +cross_condition_probe: + enabled: false +io: + require_complete_cache: false + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/hek/predictions/dual_nucl_memb_fcmae_vscyto3d_pretrained_cytoland_a549xy.zarr +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +conditions: +- name: celldiff_r2__ipsc_trained__hek + benchmark: + dataset_ref: + dataset: hek-mantis-kras-a549xy + target: kras + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/membrane/celldiff_r2_iterative/ipsc/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/hek__a549xy +- name: celldiff_r2__a549_trained__hek + benchmark: + dataset_ref: + dataset: hek-mantis-kras-a549xy + target: kras + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/membrane/celldiff_r2/a549/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/hek__a549xy +- name: celldiff_r2__joint__hek + benchmark: + dataset_ref: + dataset: hek-mantis-kras-a549xy + target: kras + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/membrane/celldiff_r2/joint/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/hek__a549xy diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_hek_a549xy_pix2pix/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_hek_a549xy_pix2pix/eval_grouped.yaml new file mode 100644 index 000000000..c1341d599 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_hek_a549xy_pix2pix/eval_grouped.yaml @@ -0,0 +1,64 @@ +# @package _global_ +# Grouped leaf: pix2pix3d arm of the HEK293T membrane (KRAS) probe, a549xy geometry. +# +# Split out of membrane_hek_a549xy for the same reason as the CELL-Diff pair: the +# regression rows were already evaluated and must not be gated behind a later +# arm's predicts. All three leaves read the same manifest gt_cache_dir, so this +# one finds the GT features warm and pays only for its own prediction side. +# Every option below matches the siblings exactly — the rows must be comparable. +# +# Unlike CELL-Diff there is no pool-dependent path token: pix2pix3d writes under +# pix2pix3d_unetvit for all three training pools. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +# Carved cpdino whole-cell, seeded by a PREDICTED nucleus channel (the HEK release +# ships none). Rationale, caveats and the seed provenance live in the sibling +# membrane_hek_a549xy/eval_grouped.yaml — keep these four settings in lockstep +# with it or the rows stop being comparable. +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei_prediction +cross_condition_probe: + enabled: false +io: + require_complete_cache: false + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/hek/predictions/dual_nucl_memb_fcmae_vscyto3d_pretrained_cytoland_a549xy.zarr +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +conditions: +- name: pix2pix3d__ipsc_trained__hek + benchmark: + dataset_ref: + dataset: hek-mantis-kras-a549xy + target: kras + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/membrane/pix2pix3d_unetvit/ipsc/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/hek__a549xy +- name: pix2pix3d__a549_trained__hek + benchmark: + dataset_ref: + dataset: hek-mantis-kras-a549xy + target: kras + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/membrane/pix2pix3d_unetvit/a549/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/hek__a549xy +- name: pix2pix3d__joint__hek + benchmark: + dataset_ref: + dataset: hek-mantis-kras-a549xy + target: kras + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/membrane/pix2pix3d_unetvit/joint/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/hek__a549xy diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained/eval_grouped.yaml index 160b4f054..3841dd284 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained/eval_grouped.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained/eval_grouped.yaml @@ -13,10 +13,8 @@ force_recompute: final_metrics: true compute_instance_ap: true segmentation: - backend: cellpose_watershed + backend: cpdino nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: false conditions: - name: celldiff_r2_iterative__ipsc_trained__a549_denv benchmark: @@ -24,275 +22,275 @@ conditions: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_iterative_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_r2_iterative/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_celldiff_r2_iterative_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/a549__denv - name: vscyto3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__denv - name: unext2__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unext2_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/a549__denv - name: fnet3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fnet3d_paper/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet3d_paper/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_fnet3d_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/a549__denv - name: pix2pix3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit__caax_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/pix2pix3d_unetvit/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix3d_unetvit/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_pix2pix3d_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__denv - name: unetvit3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_unetvit3d_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/unetvit3d/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/unetvit3d/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unetvit3d_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/a549__denv - name: celldiff_r2_iterative__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_iterative_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_r2_iterative/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_celldiff_r2_iterative_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/a549__mock - name: vscyto3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__mock - name: unext2__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unext2_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/a549__mock - name: fnet3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fnet3d_paper/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet3d_paper/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_fnet3d_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/a549__mock - name: pix2pix3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit__caax_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/pix2pix3d_unetvit/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix3d_unetvit/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_pix2pix3d_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__mock - name: unetvit3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_unetvit3d_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/unetvit3d/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/unetvit3d/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unetvit3d_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/a549__mock - name: celldiff_r2_iterative__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_iterative_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_r2_iterative/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_celldiff_r2_iterative_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/a549__zikv - name: vscyto3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__zikv - name: unext2__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unext2_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/a549__zikv - name: fnet3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fnet3d_paper/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet3d_paper/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_fnet3d_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/a549__zikv - name: pix2pix3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit__caax_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/pix2pix3d_unetvit/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix3d_unetvit/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_pix2pix3d_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__zikv - name: unetvit3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_unetvit3d_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/unetvit3d/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/unetvit3d/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unetvit3d_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/a549__zikv - name: celldiff_r2_denoise__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_celldiff_r2_denoise.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/celldiff_r2_denoise/membrane_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_denoise/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/celldiff_r2_denoise/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_celldiff_r2_denoise_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_denoise/ipsc/ipsc - name: celldiff_r2_iterative__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_celldiff_r2_iterative.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/membrane_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/celldiff_r2_iterative/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_celldiff_r2_iterative_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/ipsc - name: celldiff_r2_sliding_window__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_celldiff_r2_sliding_window.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/celldiff_r2_sliding_window/membrane_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_sliding_window/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/celldiff_r2_sliding_window/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_celldiff_r2_sliding_window_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_sliding_window/ipsc/ipsc - name: vscyto3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fcmae_vscyto3d_pretrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/membrane_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_vscyto3d_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/ipsc - name: unext2__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fcmae_vscyto3d_scratch.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/membrane_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_unext2_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/ipsc - name: fnet3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fnet3d_paper.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/fnet3d_paper/membrane_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fnet3d_paper/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_fnet3d_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/ipsc - name: pix2pix3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_pix2pix3d_unetvit.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/pix2pix3d_unetvit/membrane_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/pix2pix3d_unetvit/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_pix2pix3d_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/ipsc - name: unetvit3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_unetvit3d.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/unetvit3d/membrane_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/unetvit3d/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_unetvit3d_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained__2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained__2d/eval_grouped.yaml new file mode 100644 index 000000000..c23522e19 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained__2d/eval_grouped.yaml @@ -0,0 +1,301 @@ +# @package _global_ +# Focused sibling of grouped/membrane_ipsc_trained: ONLY the in-focus 2D conditions -- +# fnet2d + FCMAE-2D (unext2_2d, vscyto2d) + celldiff_2d + pix2pix2d +# x {ipsc, a549 mock/denv/zikv} = 20. +# Condition blocks are copied verbatim from a generate_grouped_eval_configs.py run, +# so they stay byte-identical to what the canonical bucket would emit -- only the +# selection is narrowed. +# +# celldiff_2d was folded in on 2026-08-04, once its predicts finished. It was held +# out until then because the generator's only freshness gate is pred_path.is_dir(), +# which passes on a partially-written store (measured 4813 of 5787 chunk files on a +# live nucleus/celldiff_2d/ipsc/a549__denv). The gate applied by hand instead was a +# per-store chunk count against the fnet2d store for the same organelle/pool/bucket, +# required to match exactly. The complete size is a property of (organelle, bucket), +# not a constant: 4270-4300 on the iPSC buckets and 5211-5787 on the A549 ones, and +# er/a549__denv is the low outlier at 5211 in EVERY pool. That one was confirmed +# against two further fully-evaluated models (both FCMAE-2D arms, also 5211, same 12 +# FOVs) so it is the true size and not a shortfall shared with the reference -- which +# a fnet2d-relative gate cannot see by itself. Plus sacct COMPLETED 0:0 on all 48 +# CELLDiff2D_PRED jobs. +# +# pix2pix2d was folded in on 2026-08-05, once its 48 predicts finished (all COMPLETED +# 0:0). Held out for the same reason, but gated harder than celldiff_2d was: per array, +# the expected chunk count = prod(ceil(shape / chunks)) read analytically from that +# array's own zarr.json, compared against the files actually present. That catches a +# truncated write inside a position without needing a reference family at all, which +# is what a fnet2d-relative count could not do. It is paired with a position-set +# comparison against a family already known complete, because a store missing whole +# FOVs is internally self-consistent and its own metadata can never reveal the gap. +# All 48 passed both checks: 100 positions per iPSC bucket, 12 per A549 bucket, every +# array fully chunked (.tmp/pix2pix2d/verify_predict_stores.py). +# +# Why a sibling instead of folding the 2D models into the canonical bucket: +# 1. The generator sets force_recompute.final_metrics: true, so the canonical +# bucket's already-evaluated 3D conditions would ALL recompute, not cache-skip. +# 2. Fairness. The global pixel metrics (PCC/SSIM/FSC/PSNR/Spectral_PCC), +# MicroMS3IM and the CP regionprops are computed over the FULL 3D volume, +# while per-cell similarity, the deep features (DINOv3/DynaCLR/CellDINO/ +# MorphEm) and instance AP are focus-restricted (pipeline.py). Only the +# focus-restricted families are a fair 2D-vs-3D comparison -- a per-z 2D model +# is penalised by the volume-reconstruction columns for planes it never +# targeted (2d-infocus-vs-models.md 1a). The full-3D columns are still +# computed here as diagnostics; they are NOT publishable as 2D-vs-3D. +# +# force_recompute: every pred_* artifact is forced, plus final_metrics. +# +# Until 2026-09-10 this block was `final_metrics: false`, on the grounds that 16 of +# the 20 conditions were already fully evaluated (verified 2026-08-05) and could +# cache-skip. That is now WRONG and the flag is inverted: an affine bug blanked the +# training data at z_window_size=1 (fixed in VisCy 9640537d), so 4 of the 5 2D +# families -- pix2pix2d, celldiff_2d and both FCMAE-2D arms -- were retrained from +# scratch and ALL 192 2D predictions were regenerated 2026-09-10..14. fnet2d is the +# only family that was never affected (flip-only augmentation). +# +# The prediction stores were rewritten IN PLACE with --overwrite, and the eval caches +# carry no prediction provenance -- nothing in the cache key changes when the pixels +# behind it change. So `final_metrics: true` alone is NOT enough: it would recompute +# the summary while still reading August's cached masks, instances and deep features. +# Every pred_* flag has to be forced for the numbers to reflect the new predictions. +# +# gt_* stays false deliberately. The ground truth did not change, and the GT-side deep +# features are the expensive half of a cold extraction. Do not set force_recompute.all +# -- it forces gt_* too (see _resolve_force in evaluation/pipeline_cache.py). +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +conditions: +- name: celldiff_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/a549__denv +- name: vscyto2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__denv +- name: unext2_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/a549__denv +- name: fnet2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__denv +- name: pix2pix2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/a549__denv +- name: celldiff_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/a549__mock +- name: vscyto2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__mock +- name: unext2_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/a549__mock +- name: fnet2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__mock +- name: pix2pix2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/a549__mock +- name: celldiff_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/a549__zikv +- name: vscyto2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__zikv +- name: unext2_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/a549__zikv +- name: fnet2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__zikv +- name: pix2pix2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/a549__zikv +- name: celldiff_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/celldiff_2d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/ipsc +- name: vscyto2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/ipsc +- name: unext2_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/ipsc +- name: fnet2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fnet2d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/ipsc +- name: pix2pix2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/pix2pix2d_unetvit/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained__2d_focus2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained__2d_focus2d/eval_grouped.yaml new file mode 100644 index 000000000..fe6cdddd4 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained__2d_focus2d/eval_grouped.yaml @@ -0,0 +1,251 @@ +# @package _global_ +# 2D benchmark (focus2d.halfwidth=1): every metric on one GT-anchored focus plane per +# FOV/timepoint -- pixel metrics, MicroMS3IM and CP on the plane, deep features and per-cell +# similarity on its 3-plane slab, whole-cell instance masks (cpdino) on the slab MIP. The 3D +# benchmark keeps the full volume in the canonical dirs; this bucket never writes there +# (save_dir re-rooted under +# /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/). Conditions: the 20 of +# membrane_ipsc_trained__2d (5 2D families x 4 test sets), predictions unchanged. Plane +# anchor: nucleus_area on the GT Nuclei channel (iPSC and A549). Caches: +# /focus2d_h1/ (GT and pred); CP reference __focus2d_h1. Generated by +# applications/dynacell/experiments/2026-10-07_2d-vs-3d-cost/make_focus2d_buckets.py. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +focus2d: + halfwidth: 1 +conditions: +- name: celldiff_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/celldiff_2d/ipsc/a549__denv +- name: vscyto2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__denv +- name: unext2_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_scratch/ipsc/a549__denv +- name: fnet2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fnet2d/ipsc/a549__denv +- name: pix2pix2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit/ipsc/a549__denv +- name: celldiff_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/celldiff_2d/ipsc/a549__mock +- name: vscyto2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__mock +- name: unext2_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_scratch/ipsc/a549__mock +- name: fnet2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fnet2d/ipsc/a549__mock +- name: pix2pix2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit/ipsc/a549__mock +- name: celldiff_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/celldiff_2d/ipsc/a549__zikv +- name: vscyto2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__zikv +- name: unext2_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_scratch/ipsc/a549__zikv +- name: fnet2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fnet2d/ipsc/a549__zikv +- name: pix2pix2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit/ipsc/a549__zikv +- name: celldiff_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/celldiff_2d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/celldiff_2d/ipsc/ipsc +- name: vscyto2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_pretrained/ipsc/ipsc +- name: unext2_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_scratch/ipsc/ipsc +- name: fnet2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fnet2d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fnet2d/ipsc/ipsc +- name: pix2pix2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/pix2pix2d_unetvit/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained__2d_focus2d_seed1/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained__2d_focus2d_seed1/eval_grouped.yaml new file mode 100644 index 000000000..7f7c99b71 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained__2d_focus2d_seed1/eval_grouped.yaml @@ -0,0 +1,211 @@ +# @package _global_ +# 2D benchmark (focus2d.halfwidth=1): every metric on one GT-anchored focus plane per +# FOV/timepoint -- pixel metrics, MicroMS3IM and CP on the plane, deep features and per-cell +# similarity on its 3-plane slab, whole-cell instance masks (cpdino) on the slab MIP. The 3D +# benchmark keeps the full volume in the canonical dirs; this bucket never writes there +# (save_dir re-rooted under +# /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/). Conditions: the 20 of +# membrane_ipsc_trained__2d (5 2D families x 4 test sets), predictions unchanged. Plane +# anchor: nucleus_area on the GT Nuclei channel (iPSC and A549). Caches: +# /focus2d_h1/ (GT and pred); CP reference __focus2d_h1. Generated by +# applications/dynacell/experiments/2026-10-07_2d-vs-3d-cost/make_focus2d_buckets.py. +# Seed replicates: the 16 conditions of membrane_ipsc_trained__2d_focus2d whose family has a +# seed1 fit (VSCyto2D has none), on the _seed1 stores. Generated by +# applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_seed_buckets.py. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +focus2d: + halfwidth: 1 +conditions: +- name: celldiff_2d_seed1__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d_seed1/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d_seed1/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/celldiff_2d_seed1/ipsc/a549__denv +- name: unext2_2d_seed1__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/a549__denv +- name: fnet2d_seed1__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d_seed1/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d_seed1/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fnet2d_seed1/ipsc/a549__denv +- name: pix2pix2d_seed1__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_seed1/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit_seed1/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_seed1/ipsc/a549__denv +- name: celldiff_2d_seed1__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d_seed1/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d_seed1/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/celldiff_2d_seed1/ipsc/a549__mock +- name: unext2_2d_seed1__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/a549__mock +- name: fnet2d_seed1__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d_seed1/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d_seed1/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fnet2d_seed1/ipsc/a549__mock +- name: pix2pix2d_seed1__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_seed1/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit_seed1/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_seed1/ipsc/a549__mock +- name: celldiff_2d_seed1__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d_seed1/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d_seed1/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/celldiff_2d_seed1/ipsc/a549__zikv +- name: unext2_2d_seed1__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/a549__zikv +- name: fnet2d_seed1__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d_seed1/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d_seed1/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fnet2d_seed1/ipsc/a549__zikv +- name: pix2pix2d_seed1__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_seed1/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit_seed1/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_seed1/ipsc/a549__zikv +- name: celldiff_2d_seed1__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d_seed1/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/celldiff_2d_seed1/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/celldiff_2d_seed1/ipsc/ipsc +- name: unext2_2d_seed1__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/ipsc +- name: fnet2d_seed1__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d_seed1/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fnet2d_seed1/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fnet2d_seed1/ipsc/ipsc +- name: pix2pix2d_seed1__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_seed1/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/pix2pix2d_unetvit_seed1/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit_seed1/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained__lite/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained__lite/eval_grouped.yaml new file mode 100644 index 000000000..0a98e2678 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained__lite/eval_grouped.yaml @@ -0,0 +1,223 @@ +# @package _global_ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained/eval_grouped.yaml. Do not edit; regenerate. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +compute_microssim: false +feature_metrics: + compute_fid: false + compute_prc: false + compute_mind: false +conditions: +- name: celldiff_r2_iterative__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/celldiff_r2_iterative/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2_iterative/ipsc/a549__denv +- name: vscyto3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__denv +- name: unext2__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/ipsc/a549__denv +- name: fnet3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/fnet3d_paper/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/ipsc/a549__denv +- name: unetvit3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/unetvit3d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/unetvit3d/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/unetvit3d/ipsc/a549__denv +- name: celldiff_r2_iterative__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/celldiff_r2_iterative/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2_iterative/ipsc/a549__mock +- name: vscyto3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__mock +- name: unext2__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/ipsc/a549__mock +- name: fnet3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/fnet3d_paper/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/ipsc/a549__mock +- name: unetvit3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/unetvit3d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/unetvit3d/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/unetvit3d/ipsc/a549__mock +- name: celldiff_r2_iterative__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/celldiff_r2_iterative/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2_iterative/ipsc/a549__zikv +- name: vscyto3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__zikv +- name: unext2__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/ipsc/a549__zikv +- name: fnet3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/fnet3d_paper/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/ipsc/a549__zikv +- name: unetvit3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/unetvit3d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/unetvit3d/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/unetvit3d/ipsc/a549__zikv +- name: celldiff_r2_iterative__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/membrane/celldiff_r2_iterative/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2_iterative/ipsc/ipsc +- name: vscyto3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/ipsc/ipsc +- name: unext2__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/ipsc/ipsc +- name: fnet3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/membrane/fnet3d_paper/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/ipsc/ipsc +- name: unetvit3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/unetvit3d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/membrane/unetvit3d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/unetvit3d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained_carved/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained_carved/eval_grouped.yaml deleted file mode 100644 index 13ca3c65f..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_ipsc_trained_carved/eval_grouped.yaml +++ /dev/null @@ -1,300 +0,0 @@ -# @package _global_ -# CARVED variant (segmentation.watershed.subtract_nuclei=true) of membrane_ipsc_trained. -# Secondary cytoplasm-boundary-fidelity metric; no-carve is the headline. -# Generated by tools/make_carved_membrane_leaves.py from membrane_ipsc_trained/eval_grouped.yaml. -target_name: membrane -compute_feature_metrics: true -use_gpu: true -io: - require_complete_cache: false -runtime: - executor: serial - fov_workers: 1 - threads_per_worker: auto -force_recompute: - final_metrics: true -compute_instance_ap: true -segmentation: - backend: cellpose_watershed - nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: true -conditions: -- name: celldiff_r2_iterative__ipsc_trained__a549_denv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-denv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_iterative_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_celldiff_r2_iterative_membrane_denv_carved -- name: vscyto3d__ipsc_trained__a549_denv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-denv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_membrane_denv_carved -- name: unext2__ipsc_trained__a549_denv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-denv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unext2_membrane_denv_carved -- name: fnet3d__ipsc_trained__a549_denv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-denv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fnet3d_paper/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_fnet3d_membrane_denv_carved -- name: pix2pix3d__ipsc_trained__a549_denv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-denv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit__caax_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/pix2pix3d_unetvit/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_pix2pix3d_membrane_denv_carved -- name: unetvit3d__ipsc_trained__a549_denv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-denv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_unetvit3d_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/unetvit3d/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unetvit3d_membrane_denv_carved -- name: celldiff_r2_iterative__ipsc_trained__a549_mock - benchmark: - dataset_ref: - dataset: a549-mantis-caax-mock - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_iterative_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_celldiff_r2_iterative_membrane_mock_carved -- name: vscyto3d__ipsc_trained__a549_mock - benchmark: - dataset_ref: - dataset: a549-mantis-caax-mock - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_membrane_mock_carved -- name: unext2__ipsc_trained__a549_mock - benchmark: - dataset_ref: - dataset: a549-mantis-caax-mock - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unext2_membrane_mock_carved -- name: fnet3d__ipsc_trained__a549_mock - benchmark: - dataset_ref: - dataset: a549-mantis-caax-mock - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fnet3d_paper/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_fnet3d_membrane_mock_carved -- name: pix2pix3d__ipsc_trained__a549_mock - benchmark: - dataset_ref: - dataset: a549-mantis-caax-mock - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit__caax_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/pix2pix3d_unetvit/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_pix2pix3d_membrane_mock_carved -- name: unetvit3d__ipsc_trained__a549_mock - benchmark: - dataset_ref: - dataset: a549-mantis-caax-mock - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_unetvit3d_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/unetvit3d/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unetvit3d_membrane_mock_carved -- name: celldiff_r2_iterative__ipsc_trained__a549_zikv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-zikv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_iterative_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_celldiff_r2_iterative_membrane_zikv_carved -- name: vscyto3d__ipsc_trained__a549_zikv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-zikv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_membrane_zikv_carved -- name: unext2__ipsc_trained__a549_zikv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-zikv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unext2_membrane_zikv_carved -- name: fnet3d__ipsc_trained__a549_zikv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-zikv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fnet3d_paper/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_fnet3d_membrane_zikv_carved -- name: pix2pix3d__ipsc_trained__a549_zikv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-zikv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit__caax_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/pix2pix3d_unetvit/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_pix2pix3d_membrane_zikv_carved -- name: unetvit3d__ipsc_trained__a549_zikv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-zikv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_unetvit3d_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/unetvit3d/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unetvit3d_membrane_zikv_carved -- name: celldiff_r2_denoise__ipsc_trained__ipsc - benchmark: - dataset_ref: - dataset: aics-hipsc - target: membrane - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_celldiff_r2_denoise.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/celldiff_r2_denoise/membrane_ipsc - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_celldiff_r2_denoise_membrane_carved -- name: celldiff_r2_iterative__ipsc_trained__ipsc - benchmark: - dataset_ref: - dataset: aics-hipsc - target: membrane - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_celldiff_r2_iterative.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/membrane_ipsc - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_celldiff_r2_iterative_membrane_carved -- name: celldiff_r2_sliding_window__ipsc_trained__ipsc - benchmark: - dataset_ref: - dataset: aics-hipsc - target: membrane - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_celldiff_r2_sliding_window.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/celldiff_r2_sliding_window/membrane_ipsc - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_celldiff_r2_sliding_window_membrane_carved -- name: vscyto3d__ipsc_trained__ipsc - benchmark: - dataset_ref: - dataset: aics-hipsc - target: membrane - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fcmae_vscyto3d_pretrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/membrane_ipsc - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_vscyto3d_membrane_carved -- name: unext2__ipsc_trained__ipsc - benchmark: - dataset_ref: - dataset: aics-hipsc - target: membrane - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fcmae_vscyto3d_scratch.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/membrane_ipsc - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_unext2_membrane_carved -- name: fnet3d__ipsc_trained__ipsc - benchmark: - dataset_ref: - dataset: aics-hipsc - target: membrane - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fnet3d_paper.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/fnet3d_paper/membrane_ipsc - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_fnet3d_membrane_carved -- name: pix2pix3d__ipsc_trained__ipsc - benchmark: - dataset_ref: - dataset: aics-hipsc - target: membrane - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_pix2pix3d_unetvit.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/pix2pix3d_unetvit/membrane_ipsc - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_pix2pix3d_membrane_carved -- name: unetvit3d__ipsc_trained__ipsc - benchmark: - dataset_ref: - dataset: aics-hipsc - target: membrane - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_unetvit3d.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/unetvit3d/membrane_ipsc - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_unetvit3d_membrane_carved diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint/eval_grouped.yaml index f0715b98d..dbfbb7cfa 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint/eval_grouped.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint/eval_grouped.yaml @@ -1,5 +1,5 @@ # @package _global_ -# Grouped leaf: membrane bucket, joint models (16 conditions). Auto-generated by tools/generate_grouped_eval_configs.py. +# Grouped leaf: membrane bucket, joint models (20 conditions). Auto-generated by tools/generate_grouped_eval_configs.py. target_name: membrane compute_feature_metrics: true use_gpu: true @@ -13,10 +13,8 @@ force_recompute: final_metrics: true compute_instance_ap: true segmentation: - backend: cellpose_watershed + backend: cpdino nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: false conditions: - name: celldiff_r2__joint__a549_denv benchmark: @@ -24,169 +22,212 @@ conditions: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_celldiff_r2_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/celldiff_r2/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_r2/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/a549__denv - name: vscyto3d__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fcmae_vscyto3d_pretrained_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/a549__denv - name: unext2__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fcmae_vscyto3d_scratch_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_scratch/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/a549__denv - name: fnet3d__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fnet3d_paper_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fnet3d_paper/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet3d_paper/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/a549__denv +- name: pix2pix3d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix3d_unetvit/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__denv - name: celldiff_r2__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_celldiff_r2_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/celldiff_r2/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_r2/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/a549__mock - name: vscyto3d__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fcmae_vscyto3d_pretrained_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/a549__mock - name: unext2__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fcmae_vscyto3d_scratch_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_scratch/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/a549__mock - name: fnet3d__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fnet3d_paper_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fnet3d_paper/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet3d_paper/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/a549__mock +- name: pix2pix3d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix3d_unetvit/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__mock - name: celldiff_r2__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_celldiff_r2_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/celldiff_r2/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_r2/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/a549__zikv - name: vscyto3d__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fcmae_vscyto3d_pretrained_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/a549__zikv - name: unext2__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fcmae_vscyto3d_scratch_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_scratch/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/a549__zikv - name: fnet3d__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fnet3d_paper_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fnet3d_paper/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet3d_paper/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/a549__zikv +- name: pix2pix3d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix3d_unetvit/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__zikv - name: celldiff_r2__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/memb_celldiff_r2.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/celldiff_r2/membrane_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/celldiff_r2/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/ipsc - name: vscyto3d__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/memb_fcmae_vscyto3d_pretrained_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/membrane_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fcmae_vscyto3d_pretrained/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/ipsc - name: unext2__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/memb_fcmae_vscyto3d_scratch_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/fcmae_vscyto3d_scratch/membrane_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fcmae_vscyto3d_scratch/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/ipsc - name: fnet3d__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/memb_fnet3d_paper_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/fnet3d_paper/membrane_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fnet3d_paper/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/ipsc +- name: pix2pix3d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/pix2pix3d_unetvit/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint__2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint__2d/eval_grouped.yaml new file mode 100644 index 000000000..2babb8b37 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint__2d/eval_grouped.yaml @@ -0,0 +1,301 @@ +# @package _global_ +# Focused sibling of grouped/membrane_joint: ONLY the in-focus 2D conditions -- +# fnet2d + FCMAE-2D (unext2_2d, vscyto2d) + celldiff_2d + pix2pix2d +# x {ipsc, a549 mock/denv/zikv} = 20. +# Condition blocks are copied verbatim from a generate_grouped_eval_configs.py run, +# so they stay byte-identical to what the canonical bucket would emit -- only the +# selection is narrowed. +# +# celldiff_2d was folded in on 2026-08-04, once its predicts finished. It was held +# out until then because the generator's only freshness gate is pred_path.is_dir(), +# which passes on a partially-written store (measured 4813 of 5787 chunk files on a +# live nucleus/celldiff_2d/ipsc/a549__denv). The gate applied by hand instead was a +# per-store chunk count against the fnet2d store for the same organelle/pool/bucket, +# required to match exactly. The complete size is a property of (organelle, bucket), +# not a constant: 4270-4300 on the iPSC buckets and 5211-5787 on the A549 ones, and +# er/a549__denv is the low outlier at 5211 in EVERY pool. That one was confirmed +# against two further fully-evaluated models (both FCMAE-2D arms, also 5211, same 12 +# FOVs) so it is the true size and not a shortfall shared with the reference -- which +# a fnet2d-relative gate cannot see by itself. Plus sacct COMPLETED 0:0 on all 48 +# CELLDiff2D_PRED jobs. +# +# pix2pix2d was folded in on 2026-08-05, once its 48 predicts finished (all COMPLETED +# 0:0). Held out for the same reason, but gated harder than celldiff_2d was: per array, +# the expected chunk count = prod(ceil(shape / chunks)) read analytically from that +# array's own zarr.json, compared against the files actually present. That catches a +# truncated write inside a position without needing a reference family at all, which +# is what a fnet2d-relative count could not do. It is paired with a position-set +# comparison against a family already known complete, because a store missing whole +# FOVs is internally self-consistent and its own metadata can never reveal the gap. +# All 48 passed both checks: 100 positions per iPSC bucket, 12 per A549 bucket, every +# array fully chunked (.tmp/pix2pix2d/verify_predict_stores.py). +# +# Why a sibling instead of folding the 2D models into the canonical bucket: +# 1. The generator sets force_recompute.final_metrics: true, so the canonical +# bucket's already-evaluated 3D conditions would ALL recompute, not cache-skip. +# 2. Fairness. The global pixel metrics (PCC/SSIM/FSC/PSNR/Spectral_PCC), +# MicroMS3IM and the CP regionprops are computed over the FULL 3D volume, +# while per-cell similarity, the deep features (DINOv3/DynaCLR/CellDINO/ +# MorphEm) and instance AP are focus-restricted (pipeline.py). Only the +# focus-restricted families are a fair 2D-vs-3D comparison -- a per-z 2D model +# is penalised by the volume-reconstruction columns for planes it never +# targeted (2d-infocus-vs-models.md 1a). The full-3D columns are still +# computed here as diagnostics; they are NOT publishable as 2D-vs-3D. +# +# force_recompute: every pred_* artifact is forced, plus final_metrics. +# +# Until 2026-09-10 this block was `final_metrics: false`, on the grounds that 16 of +# the 20 conditions were already fully evaluated (verified 2026-08-05) and could +# cache-skip. That is now WRONG and the flag is inverted: an affine bug blanked the +# training data at z_window_size=1 (fixed in VisCy 9640537d), so 4 of the 5 2D +# families -- pix2pix2d, celldiff_2d and both FCMAE-2D arms -- were retrained from +# scratch and ALL 192 2D predictions were regenerated 2026-09-10..14. fnet2d is the +# only family that was never affected (flip-only augmentation). +# +# The prediction stores were rewritten IN PLACE with --overwrite, and the eval caches +# carry no prediction provenance -- nothing in the cache key changes when the pixels +# behind it change. So `final_metrics: true` alone is NOT enough: it would recompute +# the summary while still reading August's cached masks, instances and deep features. +# Every pred_* flag has to be forced for the numbers to reflect the new predictions. +# +# gt_* stays false deliberately. The ground truth did not change, and the GT-side deep +# features are the expensive half of a cold extraction. Do not set force_recompute.all +# -- it forces gt_* too (see _resolve_force in evaluation/pipeline_cache.py). +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +conditions: +- name: celldiff_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/a549__denv +- name: vscyto2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/a549__denv +- name: unext2_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/a549__denv +- name: fnet2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__denv +- name: pix2pix2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/a549__denv +- name: celldiff_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/a549__mock +- name: vscyto2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/a549__mock +- name: unext2_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/a549__mock +- name: fnet2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__mock +- name: pix2pix2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/a549__mock +- name: celldiff_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/a549__zikv +- name: vscyto2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/a549__zikv +- name: unext2_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/a549__zikv +- name: fnet2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__zikv +- name: pix2pix2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/a549__zikv +- name: celldiff_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/celldiff_2d/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/ipsc +- name: vscyto2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/ipsc +- name: unext2_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/ipsc +- name: fnet2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fnet2d/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/ipsc +- name: pix2pix2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/pix2pix2d_unetvit/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint__2d_focus2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint__2d_focus2d/eval_grouped.yaml new file mode 100644 index 000000000..edf14d961 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint__2d_focus2d/eval_grouped.yaml @@ -0,0 +1,251 @@ +# @package _global_ +# 2D benchmark (focus2d.halfwidth=1): every metric on one GT-anchored focus plane per +# FOV/timepoint -- pixel metrics, MicroMS3IM and CP on the plane, deep features and per-cell +# similarity on its 3-plane slab, whole-cell instance masks (cpdino) on the slab MIP. The 3D +# benchmark keeps the full volume in the canonical dirs; this bucket never writes there +# (save_dir re-rooted under +# /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/). Conditions: the 20 of +# membrane_joint__2d (5 2D families x 4 test sets), predictions unchanged. Plane anchor: +# nucleus_area on the GT Nuclei channel (iPSC and A549). Caches: /focus2d_h1/ (GT +# and pred); CP reference __focus2d_h1. Generated by +# applications/dynacell/experiments/2026-10-07_2d-vs-3d-cost/make_focus2d_buckets.py. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +focus2d: + halfwidth: 1 +conditions: +- name: celldiff_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/celldiff_2d/joint/a549__denv +- name: vscyto2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_pretrained/joint/a549__denv +- name: unext2_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_scratch/joint/a549__denv +- name: fnet2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fnet2d/joint/a549__denv +- name: pix2pix2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit/joint/a549__denv +- name: celldiff_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/celldiff_2d/joint/a549__mock +- name: vscyto2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_pretrained/joint/a549__mock +- name: unext2_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_scratch/joint/a549__mock +- name: fnet2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fnet2d/joint/a549__mock +- name: pix2pix2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit/joint/a549__mock +- name: celldiff_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/celldiff_2d/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/celldiff_2d/joint/a549__zikv +- name: vscyto2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_pretrained/joint/a549__zikv +- name: unext2_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_scratch/joint/a549__zikv +- name: fnet2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/fnet2d/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fnet2d/joint/a549__zikv +- name: pix2pix2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix2d_unetvit/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit/joint/a549__zikv +- name: celldiff_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/celldiff_2d/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/celldiff_2d/joint/ipsc +- name: vscyto2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fcmae_vscyto2d_pretrained/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_pretrained/joint/ipsc +- name: unext2_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fcmae_vscyto2d_scratch/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fcmae_vscyto2d_scratch/joint/ipsc +- name: fnet2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/fnet2d/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/fnet2d/joint/ipsc +- name: pix2pix2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/pix2pix2d_unetvit/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/membrane/pix2pix2d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint__lite/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint__lite/eval_grouped.yaml new file mode 100644 index 000000000..8df25712b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint__lite/eval_grouped.yaml @@ -0,0 +1,63 @@ +# @package _global_ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint/eval_grouped.yaml. Do not edit; regenerate. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +compute_microssim: false +feature_metrics: + compute_fid: false + compute_prc: false + compute_mind: false +conditions: +- name: celldiff_r2__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/celldiff_r2/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/joint/a549__denv +- name: celldiff_r2__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/celldiff_r2/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/joint/a549__mock +- name: celldiff_r2__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv-lite + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/membrane/celldiff_r2/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/joint/a549__zikv +- name: celldiff_r2__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/membrane/celldiff_r2/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint_carved/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint_carved/eval_grouped.yaml deleted file mode 100644 index 21b35cb6f..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_joint_carved/eval_grouped.yaml +++ /dev/null @@ -1,194 +0,0 @@ -# @package _global_ -# CARVED variant (segmentation.watershed.subtract_nuclei=true) of membrane_joint. -# Secondary cytoplasm-boundary-fidelity metric; no-carve is the headline. -# Generated by tools/make_carved_membrane_leaves.py from membrane_joint/eval_grouped.yaml. -target_name: membrane -compute_feature_metrics: true -use_gpu: true -io: - require_complete_cache: false -runtime: - executor: serial - fov_workers: 1 - threads_per_worker: auto -force_recompute: - final_metrics: true -compute_instance_ap: true -segmentation: - backend: cellpose_watershed - nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: true -conditions: -- name: celldiff_r2__joint__a549_denv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-denv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_celldiff_r2_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/celldiff_r2/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_membrane_denv_carved -- name: vscyto3d__joint__a549_denv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-denv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fcmae_vscyto3d_pretrained_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_membrane_denv_carved -- name: unext2__joint__a549_denv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-denv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fcmae_vscyto3d_scratch_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_scratch/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_membrane_denv_carved -- name: fnet3d__joint__a549_denv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-denv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fnet3d_paper_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fnet3d_paper/caax_denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_membrane_denv_carved -- name: celldiff_r2__joint__a549_mock - benchmark: - dataset_ref: - dataset: a549-mantis-caax-mock - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_celldiff_r2_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/celldiff_r2/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_membrane_mock_carved -- name: vscyto3d__joint__a549_mock - benchmark: - dataset_ref: - dataset: a549-mantis-caax-mock - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fcmae_vscyto3d_pretrained_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_membrane_mock_carved -- name: unext2__joint__a549_mock - benchmark: - dataset_ref: - dataset: a549-mantis-caax-mock - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fcmae_vscyto3d_scratch_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_scratch/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_membrane_mock_carved -- name: fnet3d__joint__a549_mock - benchmark: - dataset_ref: - dataset: a549-mantis-caax-mock - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fnet3d_paper_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fnet3d_paper/caax_mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_membrane_mock_carved -- name: celldiff_r2__joint__a549_zikv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-zikv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_celldiff_r2_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/celldiff_r2/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_membrane_zikv_carved -- name: vscyto3d__joint__a549_zikv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-zikv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fcmae_vscyto3d_pretrained_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_membrane_zikv_carved -- name: unext2__joint__a549_zikv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-zikv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fcmae_vscyto3d_scratch_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_scratch/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_membrane_zikv_carved -- name: fnet3d__joint__a549_zikv - benchmark: - dataset_ref: - dataset: a549-mantis-caax-zikv - target: caax - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fnet3d_paper_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fnet3d_paper/caax_zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_membrane_zikv_carved -- name: celldiff_r2__joint__ipsc - benchmark: - dataset_ref: - dataset: aics-hipsc - target: membrane - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/memb_celldiff_r2.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/celldiff_r2/membrane_ipsc - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_membrane_carved -- name: vscyto3d__joint__ipsc - benchmark: - dataset_ref: - dataset: aics-hipsc - target: membrane - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/memb_fcmae_vscyto3d_pretrained_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/membrane_ipsc - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_membrane_carved -- name: unext2__joint__ipsc - benchmark: - dataset_ref: - dataset: aics-hipsc - target: membrane - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/memb_fcmae_vscyto3d_scratch_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/fcmae_vscyto3d_scratch/membrane_ipsc - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_membrane_carved -- name: fnet3d__joint__ipsc - benchmark: - dataset_ref: - dataset: aics-hipsc - target: membrane - io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/memb_fnet3d_paper_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/fnet3d_paper/membrane_ipsc - save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_membrane_carved diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_phase_floor__2d_focus2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_phase_floor__2d_focus2d/eval_grouped.yaml new file mode 100644 index 000000000..74b9e3253 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/membrane_phase_floor__2d_focus2d/eval_grouped.yaml @@ -0,0 +1,72 @@ +# @package _global_ +# 2D benchmark (focus2d.halfwidth=1): every metric on one GT-anchored focus plane per +# FOV/timepoint -- pixel metrics, MicroMS3IM and CP on the plane, deep features and per-cell +# similarity on its 3-plane slab, whole-cell instance masks (cpdino) on the slab MIP. The 3D +# benchmark keeps the full volume in the canonical dirs; this bucket never writes there +# (save_dir re-rooted under +# /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/). Phase floor: the raw +# Phase3D input scored as the prediction (io.pred_is_source) on the same planes. Plane anchor: +# nucleus_area on the GT Nuclei channel (iPSC and A549). Caches: /focus2d_h1/ (GT +# and pred); CP reference __focus2d_h1. Generated by +# applications/dynacell/experiments/2026-10-07_2d-vs-3d-cost/make_focus2d_buckets.py. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +focus2d: + halfwidth: 1 +conditions: +- name: phase__no_model__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/a549/evaluations_with_embeddings/eval_phase_membrane_denv +- name: phase__no_model__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/a549/evaluations_with_embeddings/eval_phase_membrane_mock +- name: phase__no_model__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/a549/evaluations_with_embeddings/eval_phase_membrane_zikv +- name: phase__no_model__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/ipsc/evaluations_with_embeddings/eval_phase_membrane diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria__2d_focus2d_pix2pix2d_wmatch/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria__2d_focus2d_pix2pix2d_wmatch/eval_grouped.yaml new file mode 100644 index 000000000..cdccff8ba --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria__2d_focus2d_pix2pix2d_wmatch/eval_grouped.yaml @@ -0,0 +1,167 @@ +# @package _global_ +# pix2pix2d warmup-matched refit: the pix2pix2d conditions of the mitochondria +# 2D focus2d buckets (and seed1 bucket), on the pix2pix2d_unetvit_wmatch[_seed1] stores. +# Same recipe, planes and caches as those buckets. Written by +# applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +focus2d: + halfwidth: 1 +segmentation: + focus_anchor: nucleus_area + nuclei_channel_name: Nuclei +conditions: +- name: pix2pix2d_wmatch__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit_wmatch/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit_wmatch/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d_wmatch__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit_wmatch/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit_wmatch/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d_wmatch__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d_wmatch__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/pix2pix2d_unetvit_wmatch/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit_wmatch/ipsc/ipsc +- name: pix2pix2d_wmatch__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit_wmatch/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit_wmatch/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d_wmatch__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit_wmatch/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit_wmatch/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d_wmatch__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit_wmatch/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit_wmatch/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d_wmatch__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/pix2pix2d_unetvit_wmatch/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit_wmatch/a549/ipsc +- name: pix2pix2d_wmatch__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit_wmatch/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit_wmatch/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d_wmatch__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit_wmatch/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit_wmatch/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d_wmatch__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit_wmatch/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit_wmatch/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d_wmatch__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/pix2pix2d_unetvit_wmatch/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit_wmatch/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained/eval_grouped.yaml index f9d4ad3fc..45db060dc 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained/eval_grouped.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained/eval_grouped.yaml @@ -1,5 +1,5 @@ # @package _global_ -# Grouped leaf: mitochondria bucket, a549_trained models (16 conditions). Auto-generated by tools/generate_grouped_eval_configs.py. +# Grouped leaf: mitochondria bucket, a549_trained models (24 conditions). Auto-generated by tools/generate_grouped_eval_configs.py. target_name: mitochondria compute_feature_metrics: true use_gpu: true @@ -18,157 +18,237 @@ conditions: dataset: a549-mantis-tomm20-denv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_celldiff_r2_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/celldiff_r2/tomm20_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_r2/a549/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_mitochondria_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/a549__denv - name: vscyto3d__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-tomm20-denv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/tomm20_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/a549/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_mitochondria_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/a549__denv - name: unext2__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-tomm20-denv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/tomm20_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto3d_scratch/a549/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_mitochondria_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/a549__denv - name: fnet3d__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-tomm20-denv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fnet3d_paper/tomm20_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet3d_paper/a549/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_mitochondria_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/a549__denv +- name: pix2pix3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix3d_unetvit/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__denv +- name: unetvit3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/unetvit3d/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/a549__denv - name: celldiff_r2__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-tomm20-mock target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_celldiff_r2_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/celldiff_r2/tomm20_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_r2/a549/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_mitochondria_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/a549__mock - name: vscyto3d__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-tomm20-mock target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/tomm20_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/a549/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_mitochondria_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/a549__mock - name: unext2__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-tomm20-mock target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/tomm20_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto3d_scratch/a549/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_mitochondria_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/a549__mock - name: fnet3d__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-tomm20-mock target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fnet3d_paper/tomm20_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet3d_paper/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/a549__mock +- name: pix2pix3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix3d_unetvit/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__mock +- name: unetvit3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/unetvit3d/a549/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_mitochondria_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/a549__mock - name: celldiff_r2__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-tomm20-zikv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_celldiff_r2_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/celldiff_r2/tomm20_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_r2/a549/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_mitochondria_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/a549__zikv - name: vscyto3d__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-tomm20-zikv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/tomm20_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/a549/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_mitochondria_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/a549__zikv - name: unext2__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-tomm20-zikv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/tomm20_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto3d_scratch/a549/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_mitochondria_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/a549__zikv - name: fnet3d__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-tomm20-zikv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fnet3d_paper/tomm20_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet3d_paper/a549/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_mitochondria_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/a549__zikv +- name: pix2pix3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix3d_unetvit/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__zikv +- name: unetvit3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/unetvit3d/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/a549__zikv - name: celldiff_r2__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_celldiff_r2_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/celldiff_r2/mitochondria_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/celldiff_r2/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_mitochondria + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/ipsc - name: vscyto3d__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_fcmae_vscyto3d_pretrained_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/mitochondria_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_mitochondria + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/ipsc - name: unext2__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_fcmae_vscyto3d_scratch_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/mitochondria_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fcmae_vscyto3d_scratch/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_mitochondria + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/ipsc - name: fnet3d__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_fnet3d_paper_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/fnet3d_paper/mitochondria_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fnet3d_paper/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/ipsc +- name: pix2pix3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/pix2pix3d_unetvit/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/ipsc +- name: unetvit3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/unetvit3d/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_mitochondria + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained__2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained__2d/eval_grouped.yaml new file mode 100644 index 000000000..e8aa55e06 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained__2d/eval_grouped.yaml @@ -0,0 +1,282 @@ +# @package _global_ +# Focused sibling of grouped/mitochondria_a549_trained: ONLY the in-focus 2D conditions -- +# fnet2d + FCMAE-2D (unext2_2d, vscyto2d) + celldiff_2d + pix2pix2d +# x {ipsc, a549 mock/denv/zikv} = 20. +# Condition blocks are copied verbatim from a generate_grouped_eval_configs.py run, +# so they stay byte-identical to what the canonical bucket would emit -- only the +# selection is narrowed. +# +# celldiff_2d was folded in on 2026-08-04, once its predicts finished. It was held +# out until then because the generator's only freshness gate is pred_path.is_dir(), +# which passes on a partially-written store (measured 4813 of 5787 chunk files on a +# live nucleus/celldiff_2d/ipsc/a549__denv). The gate applied by hand instead was a +# per-store chunk count against the fnet2d store for the same organelle/pool/bucket, +# required to match exactly. The complete size is a property of (organelle, bucket), +# not a constant: 4270-4300 on the iPSC buckets and 5211-5787 on the A549 ones, and +# er/a549__denv is the low outlier at 5211 in EVERY pool. That one was confirmed +# against two further fully-evaluated models (both FCMAE-2D arms, also 5211, same 12 +# FOVs) so it is the true size and not a shortfall shared with the reference -- which +# a fnet2d-relative gate cannot see by itself. Plus sacct COMPLETED 0:0 on all 48 +# CELLDiff2D_PRED jobs. +# +# pix2pix2d was folded in on 2026-08-05, once its 48 predicts finished (all COMPLETED +# 0:0). Held out for the same reason, but gated harder than celldiff_2d was: per array, +# the expected chunk count = prod(ceil(shape / chunks)) read analytically from that +# array's own zarr.json, compared against the files actually present. That catches a +# truncated write inside a position without needing a reference family at all, which +# is what a fnet2d-relative count could not do. It is paired with a position-set +# comparison against a family already known complete, because a store missing whole +# FOVs is internally self-consistent and its own metadata can never reveal the gap. +# All 48 passed both checks: 100 positions per iPSC bucket, 12 per A549 bucket, every +# array fully chunked (.tmp/pix2pix2d/verify_predict_stores.py). +# +# Why a sibling instead of folding the 2D models into the canonical bucket: +# 1. The generator sets force_recompute.final_metrics: true, so the canonical +# bucket's already-evaluated 3D conditions would ALL recompute, not cache-skip. +# 2. Fairness. The global pixel metrics (PCC/SSIM/FSC/PSNR/Spectral_PCC), +# MicroMS3IM and the CP regionprops are computed over the FULL 3D volume, +# while per-cell similarity, the deep features (DINOv3/DynaCLR/CellDINO/ +# MorphEm) and instance AP are focus-restricted (pipeline.py). Only the +# focus-restricted families are a fair 2D-vs-3D comparison -- a per-z 2D model +# is penalised by the volume-reconstruction columns for planes it never +# targeted (2d-infocus-vs-models.md 1a). The full-3D columns are still +# computed here as diagnostics; they are NOT publishable as 2D-vs-3D. +# +# force_recompute: every pred_* artifact is forced, plus final_metrics. +# +# Until 2026-09-10 this block was `final_metrics: false`, on the grounds that 16 of +# the 20 conditions were already fully evaluated (verified 2026-08-05) and could +# cache-skip. That is now WRONG and the flag is inverted: an affine bug blanked the +# training data at z_window_size=1 (fixed in VisCy 9640537d), so 4 of the 5 2D +# families -- pix2pix2d, celldiff_2d and both FCMAE-2D arms -- were retrained from +# scratch and ALL 192 2D predictions were regenerated 2026-09-10..14. fnet2d is the +# only family that was never affected (flip-only augmentation). +# +# The prediction stores were rewritten IN PLACE with --overwrite, and the eval caches +# carry no prediction provenance -- nothing in the cache key changes when the pixels +# behind it change. So `final_metrics: true` alone is NOT enough: it would recompute +# the summary while still reading August's cached masks, instances and deep features. +# Every pred_* flag has to be forced for the numbers to reflect the new predictions. +# +# gt_* stays false deliberately. The ground truth did not change, and the GT-side deep +# features are the expensive half of a cold extraction. Do not set force_recompute.all +# -- it forces gt_* too (see _resolve_force in evaluation/pipeline_cache.py). +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: celldiff_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_2d/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/a549__denv +- name: vscyto2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/a549__denv +- name: unext2_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_scratch/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/a549__denv +- name: fnet2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet2d/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/a549__denv +- name: pix2pix2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/a549__denv +- name: celldiff_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_2d/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/a549__mock +- name: vscyto2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/a549__mock +- name: unext2_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_scratch/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/a549__mock +- name: fnet2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet2d/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/a549__mock +- name: pix2pix2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/a549__mock +- name: celldiff_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_2d/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/a549__zikv +- name: vscyto2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/a549__zikv +- name: unext2_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_scratch/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/a549__zikv +- name: fnet2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet2d/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/a549__zikv +- name: pix2pix2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/a549__zikv +- name: celldiff_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/celldiff_2d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/ipsc +- name: vscyto2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/ipsc +- name: unext2_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fcmae_vscyto2d_scratch/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/ipsc +- name: fnet2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fnet2d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/ipsc +- name: pix2pix2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/pix2pix2d_unetvit/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained__2d_focus2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained__2d_focus2d/eval_grouped.yaml new file mode 100644 index 000000000..c099da37b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained__2d_focus2d/eval_grouped.yaml @@ -0,0 +1,265 @@ +# @package _global_ +# 2D benchmark (focus2d.halfwidth=1): every metric on one GT-anchored focus plane per +# FOV/timepoint -- pixel metrics, MicroMS3IM and CP on the plane, deep features and per-cell +# similarity on its 3-plane slab, semantic masks segmented on the slab and scored on its +# plane. The 3D benchmark keeps the full volume in the canonical dirs; this bucket never +# writes there (save_dir re-rooted under +# /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/). Conditions: the 20 of +# mitochondria_a549_trained__2d (5 2D families x 4 test sets), predictions unchanged. Plane +# anchor: nucleus_area on the GT Nuclei channel for iPSC, phase_midband for A549 (no nuclei). +# Caches: /focus2d_h1/ (GT and pred); CP reference __focus2d_h1. Generated +# by applications/dynacell/experiments/2026-10-07_2d-vs-3d-cost/make_focus2d_buckets.py. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +focus2d: + halfwidth: 1 +segmentation: + focus_anchor: nucleus_area + nuclei_channel_name: Nuclei +conditions: +- name: celldiff_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_2d/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/celldiff_2d/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_pretrained/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_scratch/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_scratch/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet2d/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fnet2d/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_2d/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/celldiff_2d/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_pretrained/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_scratch/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_scratch/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: fnet2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet2d/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fnet2d/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_2d/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/celldiff_2d/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_pretrained/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_scratch/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_scratch/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet2d/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fnet2d/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/celldiff_2d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/celldiff_2d/a549/ipsc +- name: vscyto2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_pretrained/a549/ipsc +- name: unext2_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fcmae_vscyto2d_scratch/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_scratch/a549/ipsc +- name: fnet2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fnet2d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fnet2d/a549/ipsc +- name: pix2pix2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/pix2pix2d_unetvit/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained__2d_focusslab3/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained__2d_focusslab3/eval_grouped.yaml new file mode 100644 index 000000000..c98968820 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained__2d_focusslab3/eval_grouped.yaml @@ -0,0 +1,542 @@ +# @package _global_ +# 2D benchmark, ER/mito segmentation on the focus plane ("slab3"): the 3 planes centered on +# each FOV's focus plane are segmented as one small volume and only the focus plane of +# the mask is scored (focus2d.halfwidth=1, the 2D-benchmark eval mode). The 3D benchmark keeps +# whole-volume masks in the canonical eval dirs; this bucket never writes there. +# +# Models: the five 2D families from mitochondria_a549_trained__2d and the 3D models from mitochondria_a549_trained +# (CELL-Diff3D = the iterative sampler only), x the four test sets. +# Plane anchor: nucleus_area on the GT Nuclei channel for the iPSC test set, +# phase_midband (GT Phase3D) for A549, whose SEC61B/TOMM20 stores carry no nuclei. +# +# Output: save_dir = canonical eval dir re-rooted under /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/. Only mask_metrics.* are +# the product. Feature metrics, MicroMS3IM, FSC and Spectral PCC are off (pixel_metrics.csv +# holds the other focus-plane pixel metrics); masks are not cached (milliseconds per slab). +# Generated by applications/dynacell/experiments/2026-10-06_2d-focus-slab3/make_buckets.py. +target_name: mitochondria +compute_feature_metrics: false +compute_microssim: false +use_gpu: true +io: + require_complete_cache: false +pixel_metrics: + fsc: null + spectral_pcc: null +focus2d: + halfwidth: 1 +segmentation: + focus_anchor: nucleus_area + nuclei_channel_name: Nuclei +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +conditions: +- name: celldiff_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_2d/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_pretrained/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_scratch/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet2d/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix2d_unetvit/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_2d/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_pretrained/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_scratch/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: fnet2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet2d/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix2d_unetvit/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_2d/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_pretrained/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_scratch/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet2d/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix2d_unetvit/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_2d/a549/ipsc +- name: vscyto2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_pretrained/a549/ipsc +- name: unext2_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_scratch/a549/ipsc +- name: fnet2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet2d/a549/ipsc +- name: pix2pix2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix2d_unetvit/a549/ipsc +- name: celldiff_r2__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_r2/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: vscyto3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_pretrained/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unext2__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_scratch/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: fnet3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet3d_paper/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix3d_unetvit/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unetvit3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/unetvit3d/a549/a549__denv + segmentation: + focus_anchor: phase_midband +- name: celldiff_r2__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_r2/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: vscyto3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_pretrained/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unext2__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_scratch/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: fnet3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet3d_paper/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix3d_unetvit/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unetvit3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/unetvit3d/a549/a549__mock + segmentation: + focus_anchor: phase_midband +- name: celldiff_r2__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_r2/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: vscyto3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_pretrained/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unext2__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_scratch/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: fnet3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet3d_paper/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix3d_unetvit/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unetvit3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/unetvit3d/a549/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: celldiff_r2__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_r2/a549/ipsc +- name: vscyto3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_pretrained/a549/ipsc +- name: unext2__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_scratch/a549/ipsc +- name: fnet3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet3d_paper/a549/ipsc +- name: pix2pix3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix3d_unetvit/a549/ipsc +- name: unetvit3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/unetvit3d/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained__lite/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained__lite/eval_grouped.yaml new file mode 100644 index 000000000..f2030094d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained__lite/eval_grouped.yaml @@ -0,0 +1,219 @@ +# @package _global_ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_a549_trained/eval_grouped.yaml. Do not edit; regenerate. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +compute_microssim: false +feature_metrics: + compute_fid: false + compute_prc: false + compute_mind: false +conditions: +- name: celldiff_r2__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/celldiff_r2/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/a549/a549__denv +- name: vscyto3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/a549/a549__denv +- name: unext2__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/fcmae_vscyto3d_scratch/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/a549/a549__denv +- name: fnet3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/fnet3d_paper/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/a549/a549__denv +- name: unetvit3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/unetvit3d/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/a549/a549__denv +- name: celldiff_r2__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/celldiff_r2/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/a549/a549__mock +- name: vscyto3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/a549/a549__mock +- name: unext2__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/fcmae_vscyto3d_scratch/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/a549/a549__mock +- name: fnet3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/fnet3d_paper/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/a549/a549__mock +- name: unetvit3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/unetvit3d/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/a549/a549__mock +- name: celldiff_r2__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/celldiff_r2/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/a549/a549__zikv +- name: vscyto3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/a549/a549__zikv +- name: unext2__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/fcmae_vscyto3d_scratch/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/a549/a549__zikv +- name: fnet3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/fnet3d_paper/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/a549/a549__zikv +- name: unetvit3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/unetvit3d/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/a549/a549__zikv +- name: celldiff_r2__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/mito/celldiff_r2/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/a549/ipsc +- name: vscyto3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/a549/ipsc +- name: unext2__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/mito/fcmae_vscyto3d_scratch/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/a549/ipsc +- name: fnet3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/mito/fnet3d_paper/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/a549/ipsc +- name: unetvit3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/mito/unetvit3d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_hek_a549xy/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_hek_a549xy/eval_grouped.yaml new file mode 100644 index 000000000..d54bd1774 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_hek_a549xy/eval_grouped.yaml @@ -0,0 +1,103 @@ +# @package _global_ +# Grouped leaf: HEK293T mitochondria (TOMM70A) third-cell-type probe, a549xy +# geometry. NeurIPS response item O — see the membrane_hek_a549xy sibling for the +# full rationale and for why this is hand-written rather than generated. +# +# Six model conditions: the paper's regression pair (FNet3D, VSCyto3D) x three +# training pools. CELL-Diff lives in mitochondria_hek_a549xy_celldiff. +# +# The marker differs from the A549/iPSC rows (TOMM70A here vs TOMM20 there) — +# both are outer-mitochondrial-membrane tags, so the morphology being predicted is +# the same, but the row is a marker shift on top of the cell-type shift. +# +# This bucket's mask tier is like-for-like with the A549/iPSC mito rows: mito +# routes to the cubic port of the classical TOMM20 workflow in +# evaluation/segmentation.py::segment, which has no training domain at all, so +# unlike membrane there is no segmenter-domain caveat on Dice. +# +# focus.* stays at the eval.yaml defaults (lambda_ill 0.450) to match the zattrs +# the HEK stores were built with — see the membrane sibling. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +cross_condition_probe: + enabled: false +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +conditions: +- name: fnet3d__ipsc_trained__hek + benchmark: + dataset_ref: + dataset: hek-mantis-tomm70a-a549xy + target: tomm70a + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/mito/fnet3d_paper/ipsc/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/hek__a549xy +- name: fnet3d__a549_trained__hek + benchmark: + dataset_ref: + dataset: hek-mantis-tomm70a-a549xy + target: tomm70a + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/mito/fnet3d_paper/a549/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/hek__a549xy +- name: fnet3d__joint__hek + benchmark: + dataset_ref: + dataset: hek-mantis-tomm70a-a549xy + target: tomm70a + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/mito/fnet3d_paper/joint/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/hek__a549xy +- name: vscyto3d__ipsc_trained__hek + benchmark: + dataset_ref: + dataset: hek-mantis-tomm70a-a549xy + target: tomm70a + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/ipsc/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/hek__a549xy +- name: vscyto3d__a549_trained__hek + benchmark: + dataset_ref: + dataset: hek-mantis-tomm70a-a549xy + target: tomm70a + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/a549/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/hek__a549xy +- name: vscyto3d__joint__hek + benchmark: + dataset_ref: + dataset: hek-mantis-tomm70a-a549xy + target: tomm70a + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/joint/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/hek__a549xy +# No-model floor, last — see the membrane sibling. +- name: phase__no_model__hek + benchmark: + dataset_ref: + dataset: hek-mantis-tomm70a-a549xy + target: tomm70a + io: + pred_is_source: true + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/hek/evaluations_with_embeddings/eval_phase_mito_a549xy diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_hek_a549xy_celldiff/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_hek_a549xy_celldiff/eval_grouped.yaml new file mode 100644 index 000000000..7f27942b9 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_hek_a549xy_celldiff/eval_grouped.yaml @@ -0,0 +1,49 @@ +# @package _global_ +# Grouped leaf: CELL-Diff arm of the HEK293T mitochondria (TOMM70A) probe, a549xy +# geometry. Split out of mitochondria_hek_a549xy for the same reason as the +# membrane pair — see membrane_hek_a549xy_celldiff. Options match the sibling +# exactly so the rows stay comparable. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +cross_condition_probe: + enabled: false +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +conditions: +- name: celldiff_r2__ipsc_trained__hek + benchmark: + dataset_ref: + dataset: hek-mantis-tomm70a-a549xy + target: tomm70a + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/mito/celldiff_r2_iterative/ipsc/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/hek__a549xy +- name: celldiff_r2__a549_trained__hek + benchmark: + dataset_ref: + dataset: hek-mantis-tomm70a-a549xy + target: tomm70a + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/mito/celldiff_r2/a549/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/hek__a549xy +- name: celldiff_r2__joint__hek + benchmark: + dataset_ref: + dataset: hek-mantis-tomm70a-a549xy + target: tomm70a + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/mito/celldiff_r2/joint/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/hek__a549xy diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_hek_a549xy_pix2pix/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_hek_a549xy_pix2pix/eval_grouped.yaml new file mode 100644 index 000000000..a8e4761a7 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_hek_a549xy_pix2pix/eval_grouped.yaml @@ -0,0 +1,55 @@ +# @package _global_ +# Grouped leaf: pix2pix3d arm of the HEK293T mitochondria (TOMM70A) probe, a549xy +# geometry. Split out of mitochondria_hek_a549xy for the same reason as the +# membrane pair — see membrane_hek_a549xy_pix2pix. Options match the siblings +# exactly so the rows stay comparable. +# +# All three pools, as of 2026-07-28. The iPSC-trained arm was absent because that +# fit had never been submitted -- its train_4gpu_modernized.yml was the only gap in +# the 12-cell pix2pix (4 organelles x 3 pools) grid, and wandb held A549_TOMM20 and +# JOINT_TOMM20 with no iPSC_TOMM20 run in any state. The backfill fit (job 35053575) +# finished COMPLETED 0:0 at wandb epoch 39/40, so the third condition is now live. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +cross_condition_probe: + enabled: false +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +conditions: +- name: pix2pix3d__ipsc_trained__hek + benchmark: + dataset_ref: + dataset: hek-mantis-tomm70a-a549xy + target: tomm70a + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/mito/pix2pix3d_unetvit/ipsc/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/hek__a549xy +- name: pix2pix3d__a549_trained__hek + benchmark: + dataset_ref: + dataset: hek-mantis-tomm70a-a549xy + target: tomm70a + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/mito/pix2pix3d_unetvit/a549/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/hek__a549xy +- name: pix2pix3d__joint__hek + benchmark: + dataset_ref: + dataset: hek-mantis-tomm70a-a549xy + target: tomm70a + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/hek__a549xy/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache_pred/mito/pix2pix3d_unetvit/joint/hek__a549xy + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/hek__a549xy diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained/eval_grouped.yaml index 78c4b994f..fa0c47526 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained/eval_grouped.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained/eval_grouped.yaml @@ -1,5 +1,5 @@ # @package _global_ -# Grouped leaf: mitochondria bucket, ipsc_trained models (22 conditions). Auto-generated by tools/generate_grouped_eval_configs.py. +# Grouped leaf: mitochondria bucket, ipsc_trained models (26 conditions). Auto-generated by tools/generate_grouped_eval_configs.py. target_name: mitochondria compute_feature_metrics: true use_gpu: true @@ -18,217 +18,257 @@ conditions: dataset: a549-mantis-tomm20-denv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_celldiff_r2_iterative__tomm20_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/tomm20_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_r2_iterative/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_celldiff_r2_iterative_mitochondria_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/a549__denv - name: vscyto3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-tomm20-denv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained__tomm20_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/tomm20_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_mitochondria_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/a549__denv - name: unext2__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-tomm20-denv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch__tomm20_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/tomm20_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto3d_scratch/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unext2_mitochondria_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/a549__denv - name: fnet3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-tomm20-denv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper__tomm20_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fnet3d_paper/tomm20_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet3d_paper/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_fnet3d_mitochondria_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/a549__denv +- name: pix2pix3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix3d_unetvit/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__denv - name: unetvit3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-tomm20-denv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_unetvit3d__tomm20_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/unetvit3d/tomm20_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/unetvit3d/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unetvit3d_mitochondria_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/a549__denv - name: celldiff_r2_iterative__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-tomm20-mock target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_celldiff_r2_iterative__tomm20_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/tomm20_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_r2_iterative/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_celldiff_r2_iterative_mitochondria_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/a549__mock - name: vscyto3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-tomm20-mock target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained__tomm20_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/tomm20_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_mitochondria_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/a549__mock - name: unext2__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-tomm20-mock target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch__tomm20_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/tomm20_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto3d_scratch/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unext2_mitochondria_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/a549__mock - name: fnet3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-tomm20-mock target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper__tomm20_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fnet3d_paper/tomm20_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet3d_paper/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/a549__mock +- name: pix2pix3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix3d_unetvit/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_fnet3d_mitochondria_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__mock - name: unetvit3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-tomm20-mock target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_unetvit3d__tomm20_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/unetvit3d/tomm20_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/unetvit3d/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unetvit3d_mitochondria_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/a549__mock - name: celldiff_r2_iterative__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-tomm20-zikv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_celldiff_r2_iterative__tomm20_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/tomm20_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_r2_iterative/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_celldiff_r2_iterative_mitochondria_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/a549__zikv - name: vscyto3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-tomm20-zikv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained__tomm20_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/tomm20_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_mitochondria_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/a549__zikv - name: unext2__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-tomm20-zikv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch__tomm20_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/tomm20_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto3d_scratch/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unext2_mitochondria_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/a549__zikv - name: fnet3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-tomm20-zikv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper__tomm20_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fnet3d_paper/tomm20_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet3d_paper/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_fnet3d_mitochondria_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/a549__zikv +- name: pix2pix3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix3d_unetvit/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__zikv - name: unetvit3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-tomm20-zikv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_unetvit3d__tomm20_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/unetvit3d/tomm20_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/unetvit3d/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unetvit3d_mitochondria_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/a549__zikv - name: celldiff_r2_denoise__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_celldiff_r2_denoise.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/celldiff_r2_denoise/mitochondria_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_denoise/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/celldiff_r2_denoise/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_celldiff_r2_denoise_mitochondria + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_denoise/ipsc/ipsc - name: celldiff_r2_iterative__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_celldiff_r2_iterative.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/mitochondria_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/celldiff_r2_iterative/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_celldiff_r2_iterative_mitochondria + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/ipsc - name: celldiff_r2_sliding_window__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_celldiff_r2_sliding_window.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/celldiff_r2_sliding_window/mitochondria_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_sliding_window/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/celldiff_r2_sliding_window/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_celldiff_r2_sliding_window_mitochondria + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_sliding_window/ipsc/ipsc - name: vscyto3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_fcmae_vscyto3d_pretrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/mitochondria_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_vscyto3d_mitochondria + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/ipsc - name: unext2__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_fcmae_vscyto3d_scratch.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/mitochondria_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fcmae_vscyto3d_scratch/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_unext2_mitochondria + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/ipsc - name: fnet3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_fnet3d_paper.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/fnet3d_paper/mitochondria_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fnet3d_paper/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/ipsc +- name: pix2pix3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/pix2pix3d_unetvit/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_fnet3d_mitochondria + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/ipsc - name: unetvit3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_unetvit3d.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/unetvit3d/mitochondria_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/unetvit3d/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_unetvit3d_mitochondria + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained__2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained__2d/eval_grouped.yaml new file mode 100644 index 000000000..818121250 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained__2d/eval_grouped.yaml @@ -0,0 +1,282 @@ +# @package _global_ +# Focused sibling of grouped/mitochondria_ipsc_trained: ONLY the in-focus 2D conditions -- +# fnet2d + FCMAE-2D (unext2_2d, vscyto2d) + celldiff_2d + pix2pix2d +# x {ipsc, a549 mock/denv/zikv} = 20. +# Condition blocks are copied verbatim from a generate_grouped_eval_configs.py run, +# so they stay byte-identical to what the canonical bucket would emit -- only the +# selection is narrowed. +# +# celldiff_2d was folded in on 2026-08-04, once its predicts finished. It was held +# out until then because the generator's only freshness gate is pred_path.is_dir(), +# which passes on a partially-written store (measured 4813 of 5787 chunk files on a +# live nucleus/celldiff_2d/ipsc/a549__denv). The gate applied by hand instead was a +# per-store chunk count against the fnet2d store for the same organelle/pool/bucket, +# required to match exactly. The complete size is a property of (organelle, bucket), +# not a constant: 4270-4300 on the iPSC buckets and 5211-5787 on the A549 ones, and +# er/a549__denv is the low outlier at 5211 in EVERY pool. That one was confirmed +# against two further fully-evaluated models (both FCMAE-2D arms, also 5211, same 12 +# FOVs) so it is the true size and not a shortfall shared with the reference -- which +# a fnet2d-relative gate cannot see by itself. Plus sacct COMPLETED 0:0 on all 48 +# CELLDiff2D_PRED jobs. +# +# pix2pix2d was folded in on 2026-08-05, once its 48 predicts finished (all COMPLETED +# 0:0). Held out for the same reason, but gated harder than celldiff_2d was: per array, +# the expected chunk count = prod(ceil(shape / chunks)) read analytically from that +# array's own zarr.json, compared against the files actually present. That catches a +# truncated write inside a position without needing a reference family at all, which +# is what a fnet2d-relative count could not do. It is paired with a position-set +# comparison against a family already known complete, because a store missing whole +# FOVs is internally self-consistent and its own metadata can never reveal the gap. +# All 48 passed both checks: 100 positions per iPSC bucket, 12 per A549 bucket, every +# array fully chunked (.tmp/pix2pix2d/verify_predict_stores.py). +# +# Why a sibling instead of folding the 2D models into the canonical bucket: +# 1. The generator sets force_recompute.final_metrics: true, so the canonical +# bucket's already-evaluated 3D conditions would ALL recompute, not cache-skip. +# 2. Fairness. The global pixel metrics (PCC/SSIM/FSC/PSNR/Spectral_PCC), +# MicroMS3IM and the CP regionprops are computed over the FULL 3D volume, +# while per-cell similarity, the deep features (DINOv3/DynaCLR/CellDINO/ +# MorphEm) and instance AP are focus-restricted (pipeline.py). Only the +# focus-restricted families are a fair 2D-vs-3D comparison -- a per-z 2D model +# is penalised by the volume-reconstruction columns for planes it never +# targeted (2d-infocus-vs-models.md 1a). The full-3D columns are still +# computed here as diagnostics; they are NOT publishable as 2D-vs-3D. +# +# force_recompute: every pred_* artifact is forced, plus final_metrics. +# +# Until 2026-09-10 this block was `final_metrics: false`, on the grounds that 16 of +# the 20 conditions were already fully evaluated (verified 2026-08-05) and could +# cache-skip. That is now WRONG and the flag is inverted: an affine bug blanked the +# training data at z_window_size=1 (fixed in VisCy 9640537d), so 4 of the 5 2D +# families -- pix2pix2d, celldiff_2d and both FCMAE-2D arms -- were retrained from +# scratch and ALL 192 2D predictions were regenerated 2026-09-10..14. fnet2d is the +# only family that was never affected (flip-only augmentation). +# +# The prediction stores were rewritten IN PLACE with --overwrite, and the eval caches +# carry no prediction provenance -- nothing in the cache key changes when the pixels +# behind it change. So `final_metrics: true` alone is NOT enough: it would recompute +# the summary while still reading August's cached masks, instances and deep features. +# Every pred_* flag has to be forced for the numbers to reflect the new predictions. +# +# gt_* stays false deliberately. The ground truth did not change, and the GT-side deep +# features are the expensive half of a cold extraction. Do not set force_recompute.all +# -- it forces gt_* too (see _resolve_force in evaluation/pipeline_cache.py). +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: celldiff_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_2d/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/a549__denv +- name: vscyto2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/a549__denv +- name: unext2_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_scratch/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/a549__denv +- name: fnet2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet2d/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/a549__denv +- name: pix2pix2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/a549__denv +- name: celldiff_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_2d/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/a549__mock +- name: vscyto2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/a549__mock +- name: unext2_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_scratch/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/a549__mock +- name: fnet2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet2d/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/a549__mock +- name: pix2pix2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/a549__mock +- name: celldiff_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_2d/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/a549__zikv +- name: vscyto2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/a549__zikv +- name: unext2_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_scratch/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/a549__zikv +- name: fnet2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet2d/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/a549__zikv +- name: pix2pix2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/a549__zikv +- name: celldiff_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/celldiff_2d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/ipsc +- name: vscyto2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/ipsc +- name: unext2_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fcmae_vscyto2d_scratch/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/ipsc +- name: fnet2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fnet2d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/ipsc +- name: pix2pix2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/pix2pix2d_unetvit/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained__2d_focus2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained__2d_focus2d/eval_grouped.yaml new file mode 100644 index 000000000..886202598 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained__2d_focus2d/eval_grouped.yaml @@ -0,0 +1,265 @@ +# @package _global_ +# 2D benchmark (focus2d.halfwidth=1): every metric on one GT-anchored focus plane per +# FOV/timepoint -- pixel metrics, MicroMS3IM and CP on the plane, deep features and per-cell +# similarity on its 3-plane slab, semantic masks segmented on the slab and scored on its +# plane. The 3D benchmark keeps the full volume in the canonical dirs; this bucket never +# writes there (save_dir re-rooted under +# /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/). Conditions: the 20 of +# mitochondria_ipsc_trained__2d (5 2D families x 4 test sets), predictions unchanged. Plane +# anchor: nucleus_area on the GT Nuclei channel for iPSC, phase_midband for A549 (no nuclei). +# Caches: /focus2d_h1/ (GT and pred); CP reference __focus2d_h1. Generated +# by applications/dynacell/experiments/2026-10-07_2d-vs-3d-cost/make_focus2d_buckets.py. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +focus2d: + halfwidth: 1 +segmentation: + focus_anchor: nucleus_area + nuclei_channel_name: Nuclei +conditions: +- name: celldiff_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_2d/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/celldiff_2d/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_pretrained/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_scratch/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_scratch/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet2d/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fnet2d/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_2d/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/celldiff_2d/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_pretrained/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_scratch/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_scratch/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: fnet2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet2d/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fnet2d/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_2d/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/celldiff_2d/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_pretrained/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_scratch/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_scratch/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet2d/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fnet2d/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/celldiff_2d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/celldiff_2d/ipsc/ipsc +- name: vscyto2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_pretrained/ipsc/ipsc +- name: unext2_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fcmae_vscyto2d_scratch/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_scratch/ipsc/ipsc +- name: fnet2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fnet2d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fnet2d/ipsc/ipsc +- name: pix2pix2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/pix2pix2d_unetvit/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained__2d_focusslab3/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained__2d_focusslab3/eval_grouped.yaml new file mode 100644 index 000000000..9de37940c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained__2d_focusslab3/eval_grouped.yaml @@ -0,0 +1,542 @@ +# @package _global_ +# 2D benchmark, ER/mito segmentation on the focus plane ("slab3"): the 3 planes centered on +# each FOV's focus plane are segmented as one small volume and only the focus plane of +# the mask is scored (focus2d.halfwidth=1, the 2D-benchmark eval mode). The 3D benchmark keeps +# whole-volume masks in the canonical eval dirs; this bucket never writes there. +# +# Models: the five 2D families from mitochondria_ipsc_trained__2d and the 3D models from mitochondria_ipsc_trained +# (CELL-Diff3D = the iterative sampler only), x the four test sets. +# Plane anchor: nucleus_area on the GT Nuclei channel for the iPSC test set, +# phase_midband (GT Phase3D) for A549, whose SEC61B/TOMM20 stores carry no nuclei. +# +# Output: save_dir = canonical eval dir re-rooted under /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/. Only mask_metrics.* are +# the product. Feature metrics, MicroMS3IM, FSC and Spectral PCC are off (pixel_metrics.csv +# holds the other focus-plane pixel metrics); masks are not cached (milliseconds per slab). +# Generated by applications/dynacell/experiments/2026-10-06_2d-focus-slab3/make_buckets.py. +target_name: mitochondria +compute_feature_metrics: false +compute_microssim: false +use_gpu: true +io: + require_complete_cache: false +pixel_metrics: + fsc: null + spectral_pcc: null +focus2d: + halfwidth: 1 +segmentation: + focus_anchor: nucleus_area + nuclei_channel_name: Nuclei +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +conditions: +- name: celldiff_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_2d/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_pretrained/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_scratch/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet2d/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix2d_unetvit/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_2d/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_pretrained/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_scratch/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: fnet2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet2d/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix2d_unetvit/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_2d/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_pretrained/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_scratch/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet2d/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix2d_unetvit/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_2d/ipsc/ipsc +- name: vscyto2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_pretrained/ipsc/ipsc +- name: unext2_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_scratch/ipsc/ipsc +- name: fnet2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet2d/ipsc/ipsc +- name: pix2pix2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix2d_unetvit/ipsc/ipsc +- name: celldiff_r2_iterative__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_r2_iterative/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: vscyto3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_pretrained/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unext2__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_scratch/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: fnet3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet3d_paper/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix3d_unetvit/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unetvit3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/unetvit3d/ipsc/a549__denv + segmentation: + focus_anchor: phase_midband +- name: celldiff_r2_iterative__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_r2_iterative/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: vscyto3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_pretrained/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unext2__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_scratch/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: fnet3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet3d_paper/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix3d_unetvit/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unetvit3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/unetvit3d/ipsc/a549__mock + segmentation: + focus_anchor: phase_midband +- name: celldiff_r2_iterative__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_r2_iterative/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: vscyto3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_pretrained/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unext2__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_scratch/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: fnet3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet3d_paper/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix3d_unetvit/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unetvit3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/unetvit3d/ipsc/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: celldiff_r2_iterative__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_r2_iterative/ipsc/ipsc +- name: vscyto3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_pretrained/ipsc/ipsc +- name: unext2__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_scratch/ipsc/ipsc +- name: fnet3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet3d_paper/ipsc/ipsc +- name: pix2pix3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix3d_unetvit/ipsc/ipsc +- name: unetvit3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/unetvit3d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained__lite/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained__lite/eval_grouped.yaml new file mode 100644 index 000000000..428961fa4 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained__lite/eval_grouped.yaml @@ -0,0 +1,219 @@ +# @package _global_ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_ipsc_trained/eval_grouped.yaml. Do not edit; regenerate. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +compute_microssim: false +feature_metrics: + compute_fid: false + compute_prc: false + compute_mind: false +conditions: +- name: celldiff_r2_iterative__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/celldiff_r2_iterative/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2_iterative/ipsc/a549__denv +- name: vscyto3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/ipsc/a549__denv +- name: unext2__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/fcmae_vscyto3d_scratch/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/ipsc/a549__denv +- name: fnet3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/fnet3d_paper/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/ipsc/a549__denv +- name: unetvit3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/unetvit3d/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/ipsc/a549__denv +- name: celldiff_r2_iterative__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/celldiff_r2_iterative/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2_iterative/ipsc/a549__mock +- name: vscyto3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/ipsc/a549__mock +- name: unext2__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/fcmae_vscyto3d_scratch/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/ipsc/a549__mock +- name: fnet3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/fnet3d_paper/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/ipsc/a549__mock +- name: unetvit3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/unetvit3d/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/ipsc/a549__mock +- name: celldiff_r2_iterative__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/celldiff_r2_iterative/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2_iterative/ipsc/a549__zikv +- name: vscyto3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/ipsc/a549__zikv +- name: unext2__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/fcmae_vscyto3d_scratch/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/ipsc/a549__zikv +- name: fnet3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/fnet3d_paper/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/ipsc/a549__zikv +- name: unetvit3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/unetvit3d/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/ipsc/a549__zikv +- name: celldiff_r2_iterative__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/mito/celldiff_r2_iterative/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2_iterative/ipsc/ipsc +- name: vscyto3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/ipsc/ipsc +- name: unext2__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/mito/fcmae_vscyto3d_scratch/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/ipsc/ipsc +- name: fnet3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/mito/fnet3d_paper/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/ipsc/ipsc +- name: unetvit3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/mito/unetvit3d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint/eval_grouped.yaml index 2f08316b5..06c040005 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint/eval_grouped.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint/eval_grouped.yaml @@ -1,5 +1,5 @@ # @package _global_ -# Grouped leaf: mitochondria bucket, joint models (16 conditions). Auto-generated by tools/generate_grouped_eval_configs.py. +# Grouped leaf: mitochondria bucket, joint models (24 conditions). Auto-generated by tools/generate_grouped_eval_configs.py. target_name: mitochondria compute_feature_metrics: true use_gpu: true @@ -18,157 +18,237 @@ conditions: dataset: a549-mantis-tomm20-denv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/tomm20_celldiff_r2_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/celldiff_r2/tomm20_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_r2/joint/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_mitochondria_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/a549__denv - name: vscyto3d__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-tomm20-denv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/tomm20_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/joint/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_mitochondria_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/a549__denv - name: unext2__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-tomm20-denv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_scratch/tomm20_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto3d_scratch/joint/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_mitochondria_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/a549__denv - name: fnet3d__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-tomm20-denv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fnet3d_paper/tomm20_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet3d_paper/joint/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_mitochondria_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/a549__denv +- name: pix2pix3d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix3d_unetvit/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__denv +- name: unetvit3d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/unetvit3d/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/a549__denv - name: celldiff_r2__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-tomm20-mock target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/tomm20_celldiff_r2_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/celldiff_r2/tomm20_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_r2/joint/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_mitochondria_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/a549__mock - name: vscyto3d__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-tomm20-mock target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/tomm20_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/joint/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_mitochondria_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/a549__mock - name: unext2__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-tomm20-mock target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_scratch/tomm20_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto3d_scratch/joint/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_mitochondria_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/a549__mock - name: fnet3d__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-tomm20-mock target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fnet3d_paper/tomm20_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet3d_paper/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/a549__mock +- name: pix2pix3d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix3d_unetvit/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__mock +- name: unetvit3d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/unetvit3d/joint/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_mitochondria_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/a549__mock - name: celldiff_r2__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-tomm20-zikv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/tomm20_celldiff_r2_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/celldiff_r2/tomm20_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_r2/joint/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_mitochondria_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/a549__zikv - name: vscyto3d__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-tomm20-zikv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/tomm20_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/joint/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_mitochondria_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/a549__zikv - name: unext2__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-tomm20-zikv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_scratch/tomm20_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto3d_scratch/joint/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_mitochondria_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/a549__zikv - name: fnet3d__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-tomm20-zikv target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fnet3d_paper/tomm20_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet3d_paper/joint/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_mitochondria_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/a549__zikv +- name: pix2pix3d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix3d_unetvit/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__zikv +- name: unetvit3d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/unetvit3d/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/a549__zikv - name: celldiff_r2__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/tomm20_celldiff_r2.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/celldiff_r2/mitochondria_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/celldiff_r2/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_mitochondria + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/ipsc - name: vscyto3d__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_fcmae_vscyto3d_pretrained_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/mitochondria_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fcmae_vscyto3d_pretrained/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_mitochondria + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/ipsc - name: unext2__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_fcmae_vscyto3d_scratch_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/fcmae_vscyto3d_scratch/mitochondria_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fcmae_vscyto3d_scratch/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_mitochondria + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/ipsc - name: fnet3d__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: tomm20 io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_fnet3d_paper_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/fnet3d_paper/mitochondria_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fnet3d_paper/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/ipsc +- name: pix2pix3d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/pix2pix3d_unetvit/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/ipsc +- name: unetvit3d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/unetvit3d/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_mitochondria + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint__2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint__2d/eval_grouped.yaml new file mode 100644 index 000000000..08a176960 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint__2d/eval_grouped.yaml @@ -0,0 +1,282 @@ +# @package _global_ +# Focused sibling of grouped/mitochondria_joint: ONLY the in-focus 2D conditions -- +# fnet2d + FCMAE-2D (unext2_2d, vscyto2d) + celldiff_2d + pix2pix2d +# x {ipsc, a549 mock/denv/zikv} = 20. +# Condition blocks are copied verbatim from a generate_grouped_eval_configs.py run, +# so they stay byte-identical to what the canonical bucket would emit -- only the +# selection is narrowed. +# +# celldiff_2d was folded in on 2026-08-04, once its predicts finished. It was held +# out until then because the generator's only freshness gate is pred_path.is_dir(), +# which passes on a partially-written store (measured 4813 of 5787 chunk files on a +# live nucleus/celldiff_2d/ipsc/a549__denv). The gate applied by hand instead was a +# per-store chunk count against the fnet2d store for the same organelle/pool/bucket, +# required to match exactly. The complete size is a property of (organelle, bucket), +# not a constant: 4270-4300 on the iPSC buckets and 5211-5787 on the A549 ones, and +# er/a549__denv is the low outlier at 5211 in EVERY pool. That one was confirmed +# against two further fully-evaluated models (both FCMAE-2D arms, also 5211, same 12 +# FOVs) so it is the true size and not a shortfall shared with the reference -- which +# a fnet2d-relative gate cannot see by itself. Plus sacct COMPLETED 0:0 on all 48 +# CELLDiff2D_PRED jobs. +# +# pix2pix2d was folded in on 2026-08-05, once its 48 predicts finished (all COMPLETED +# 0:0). Held out for the same reason, but gated harder than celldiff_2d was: per array, +# the expected chunk count = prod(ceil(shape / chunks)) read analytically from that +# array's own zarr.json, compared against the files actually present. That catches a +# truncated write inside a position without needing a reference family at all, which +# is what a fnet2d-relative count could not do. It is paired with a position-set +# comparison against a family already known complete, because a store missing whole +# FOVs is internally self-consistent and its own metadata can never reveal the gap. +# All 48 passed both checks: 100 positions per iPSC bucket, 12 per A549 bucket, every +# array fully chunked (.tmp/pix2pix2d/verify_predict_stores.py). +# +# Why a sibling instead of folding the 2D models into the canonical bucket: +# 1. The generator sets force_recompute.final_metrics: true, so the canonical +# bucket's already-evaluated 3D conditions would ALL recompute, not cache-skip. +# 2. Fairness. The global pixel metrics (PCC/SSIM/FSC/PSNR/Spectral_PCC), +# MicroMS3IM and the CP regionprops are computed over the FULL 3D volume, +# while per-cell similarity, the deep features (DINOv3/DynaCLR/CellDINO/ +# MorphEm) and instance AP are focus-restricted (pipeline.py). Only the +# focus-restricted families are a fair 2D-vs-3D comparison -- a per-z 2D model +# is penalised by the volume-reconstruction columns for planes it never +# targeted (2d-infocus-vs-models.md 1a). The full-3D columns are still +# computed here as diagnostics; they are NOT publishable as 2D-vs-3D. +# +# force_recompute: every pred_* artifact is forced, plus final_metrics. +# +# Until 2026-09-10 this block was `final_metrics: false`, on the grounds that 16 of +# the 20 conditions were already fully evaluated (verified 2026-08-05) and could +# cache-skip. That is now WRONG and the flag is inverted: an affine bug blanked the +# training data at z_window_size=1 (fixed in VisCy 9640537d), so 4 of the 5 2D +# families -- pix2pix2d, celldiff_2d and both FCMAE-2D arms -- were retrained from +# scratch and ALL 192 2D predictions were regenerated 2026-09-10..14. fnet2d is the +# only family that was never affected (flip-only augmentation). +# +# The prediction stores were rewritten IN PLACE with --overwrite, and the eval caches +# carry no prediction provenance -- nothing in the cache key changes when the pixels +# behind it change. So `final_metrics: true` alone is NOT enough: it would recompute +# the summary while still reading August's cached masks, instances and deep features. +# Every pred_* flag has to be forced for the numbers to reflect the new predictions. +# +# gt_* stays false deliberately. The ground truth did not change, and the GT-side deep +# features are the expensive half of a cold extraction. Do not set force_recompute.all +# -- it forces gt_* too (see _resolve_force in evaluation/pipeline_cache.py). +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: celldiff_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_2d/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/a549__denv +- name: vscyto2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/a549__denv +- name: unext2_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_scratch/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/a549__denv +- name: fnet2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet2d/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/a549__denv +- name: pix2pix2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/a549__denv +- name: celldiff_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_2d/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/a549__mock +- name: vscyto2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/a549__mock +- name: unext2_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_scratch/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/a549__mock +- name: fnet2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet2d/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/a549__mock +- name: pix2pix2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/a549__mock +- name: celldiff_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_2d/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/a549__zikv +- name: vscyto2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/a549__zikv +- name: unext2_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_scratch/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/a549__zikv +- name: fnet2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet2d/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/a549__zikv +- name: pix2pix2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/a549__zikv +- name: celldiff_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/celldiff_2d/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/ipsc +- name: vscyto2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/ipsc +- name: unext2_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fcmae_vscyto2d_scratch/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/ipsc +- name: fnet2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fnet2d/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/ipsc +- name: pix2pix2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/pix2pix2d_unetvit/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint__2d_focus2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint__2d_focus2d/eval_grouped.yaml new file mode 100644 index 000000000..3701ac559 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint__2d_focus2d/eval_grouped.yaml @@ -0,0 +1,265 @@ +# @package _global_ +# 2D benchmark (focus2d.halfwidth=1): every metric on one GT-anchored focus plane per +# FOV/timepoint -- pixel metrics, MicroMS3IM and CP on the plane, deep features and per-cell +# similarity on its 3-plane slab, semantic masks segmented on the slab and scored on its +# plane. The 3D benchmark keeps the full volume in the canonical dirs; this bucket never +# writes there (save_dir re-rooted under +# /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/). Conditions: the 20 of +# mitochondria_joint__2d (5 2D families x 4 test sets), predictions unchanged. Plane anchor: +# nucleus_area on the GT Nuclei channel for iPSC, phase_midband for A549 (no nuclei). Caches: +# /focus2d_h1/ (GT and pred); CP reference __focus2d_h1. Generated by +# applications/dynacell/experiments/2026-10-07_2d-vs-3d-cost/make_focus2d_buckets.py. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +focus2d: + halfwidth: 1 +segmentation: + focus_anchor: nucleus_area + nuclei_channel_name: Nuclei +conditions: +- name: celldiff_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_2d/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/celldiff_2d/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_pretrained/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_scratch/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_scratch/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet2d/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fnet2d/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_2d/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/celldiff_2d/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_pretrained/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_scratch/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_scratch/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: fnet2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet2d/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fnet2d/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/celldiff_2d/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/celldiff_2d/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_pretrained/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fcmae_vscyto2d_scratch/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_scratch/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/fnet2d/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fnet2d/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix2d_unetvit/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/celldiff_2d/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/celldiff_2d/joint/ipsc +- name: vscyto2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fcmae_vscyto2d_pretrained/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_pretrained/joint/ipsc +- name: unext2_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fcmae_vscyto2d_scratch/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fcmae_vscyto2d_scratch/joint/ipsc +- name: fnet2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/fnet2d/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/fnet2d/joint/ipsc +- name: pix2pix2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/pix2pix2d_unetvit/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/mito/pix2pix2d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint__2d_focusslab3/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint__2d_focusslab3/eval_grouped.yaml new file mode 100644 index 000000000..3a18a45cb --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint__2d_focusslab3/eval_grouped.yaml @@ -0,0 +1,542 @@ +# @package _global_ +# 2D benchmark, ER/mito segmentation on the focus plane ("slab3"): the 3 planes centered on +# each FOV's focus plane are segmented as one small volume and only the focus plane of +# the mask is scored (focus2d.halfwidth=1, the 2D-benchmark eval mode). The 3D benchmark keeps +# whole-volume masks in the canonical eval dirs; this bucket never writes there. +# +# Models: the five 2D families from mitochondria_joint__2d and the 3D models from mitochondria_joint +# (CELL-Diff3D = the iterative sampler only), x the four test sets. +# Plane anchor: nucleus_area on the GT Nuclei channel for the iPSC test set, +# phase_midband (GT Phase3D) for A549, whose SEC61B/TOMM20 stores carry no nuclei. +# +# Output: save_dir = canonical eval dir re-rooted under /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/. Only mask_metrics.* are +# the product. Feature metrics, MicroMS3IM, FSC and Spectral PCC are off (pixel_metrics.csv +# holds the other focus-plane pixel metrics); masks are not cached (milliseconds per slab). +# Generated by applications/dynacell/experiments/2026-10-06_2d-focus-slab3/make_buckets.py. +target_name: mitochondria +compute_feature_metrics: false +compute_microssim: false +use_gpu: true +io: + require_complete_cache: false +pixel_metrics: + fsc: null + spectral_pcc: null +focus2d: + halfwidth: 1 +segmentation: + focus_anchor: nucleus_area + nuclei_channel_name: Nuclei +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +conditions: +- name: celldiff_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_2d/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_pretrained/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_scratch/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet2d/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix2d_unetvit/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_2d/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_pretrained/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_scratch/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: fnet2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet2d/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix2d_unetvit/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_2d/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: vscyto2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_pretrained/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unext2_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_scratch/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: fnet2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet2d/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix2d_unetvit/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: celldiff_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_2d/joint/ipsc +- name: vscyto2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_pretrained/joint/ipsc +- name: unext2_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto2d_scratch/joint/ipsc +- name: fnet2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet2d/joint/ipsc +- name: pix2pix2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix2d_unetvit/joint/ipsc +- name: celldiff_r2__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_r2/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: vscyto3d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_pretrained/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unext2__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_scratch/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: fnet3d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet3d_paper/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: pix2pix3d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix3d_unetvit/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: unetvit3d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/a549__denv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/unetvit3d/joint/a549__denv + segmentation: + focus_anchor: phase_midband +- name: celldiff_r2__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_r2/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: vscyto3d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_pretrained/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unext2__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_scratch/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: fnet3d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet3d_paper/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: pix2pix3d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix3d_unetvit/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: unetvit3d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/a549__mock/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/unetvit3d/joint/a549__mock + segmentation: + focus_anchor: phase_midband +- name: celldiff_r2__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_r2/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: vscyto3d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_pretrained/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unext2__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_scratch/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: fnet3d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet3d_paper/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: pix2pix3d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix3d_unetvit/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: unetvit3d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/a549__zikv/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/unetvit3d/joint/a549__zikv + segmentation: + focus_anchor: phase_midband +- name: celldiff_r2__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/celldiff_r2/joint/ipsc +- name: vscyto3d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_pretrained/joint/ipsc +- name: unext2__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fcmae_vscyto3d_scratch/joint/ipsc +- name: fnet3d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/fnet3d_paper/joint/ipsc +- name: pix2pix3d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/pix2pix3d_unetvit/joint/ipsc +- name: unetvit3d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/ipsc/prediction.zarr + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/mito/unetvit3d/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint__lite/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint__lite/eval_grouped.yaml new file mode 100644 index 000000000..66250224c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint__lite/eval_grouped.yaml @@ -0,0 +1,59 @@ +# @package _global_ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_joint/eval_grouped.yaml. Do not edit; regenerate. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +compute_microssim: false +feature_metrics: + compute_fid: false + compute_prc: false + compute_mind: false +conditions: +- name: celldiff_r2__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/celldiff_r2/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/joint/a549__denv +- name: celldiff_r2__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/celldiff_r2/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/joint/a549__mock +- name: celldiff_r2__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/mito/celldiff_r2/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/joint/a549__zikv +- name: celldiff_r2__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/mito/celldiff_r2/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_phase_floor__2d_focus2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_phase_floor__2d_focus2d/eval_grouped.yaml new file mode 100644 index 000000000..c90ce0137 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_phase_floor__2d_focus2d/eval_grouped.yaml @@ -0,0 +1,74 @@ +# @package _global_ +# 2D benchmark (focus2d.halfwidth=1): every metric on one GT-anchored focus plane per +# FOV/timepoint -- pixel metrics, MicroMS3IM and CP on the plane, deep features and per-cell +# similarity on its 3-plane slab, semantic masks segmented on the slab and scored on its +# plane. The 3D benchmark keeps the full volume in the canonical dirs; this bucket never +# writes there (save_dir re-rooted under +# /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/). Phase floor: the raw +# Phase3D input scored as the prediction (io.pred_is_source) on the same planes. Plane anchor: +# nucleus_area on the GT Nuclei channel for iPSC, phase_midband for A549 (no nuclei). Caches: +# /focus2d_h1/ (GT and pred); CP reference __focus2d_h1. Generated by +# applications/dynacell/experiments/2026-10-07_2d-vs-3d-cost/make_focus2d_buckets.py. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +focus2d: + halfwidth: 1 +segmentation: + focus_anchor: nucleus_area + nuclei_channel_name: Nuclei +conditions: +- name: phase__no_model__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/a549/evaluations_with_embeddings/eval_phase_mitochondria_denv + segmentation: + focus_anchor: phase_midband +- name: phase__no_model__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/a549/evaluations_with_embeddings/eval_phase_mitochondria_mock + segmentation: + focus_anchor: phase_midband +- name: phase__no_model__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/a549/evaluations_with_embeddings/eval_phase_mitochondria_zikv + segmentation: + focus_anchor: phase_midband +- name: phase__no_model__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/ipsc/evaluations_with_embeddings/eval_phase_mitochondria diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_phase_floor__2d_focusslab3/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_phase_floor__2d_focusslab3/eval_grouped.yaml new file mode 100644 index 000000000..8aa91dae1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/mitochondria_phase_floor__2d_focusslab3/eval_grouped.yaml @@ -0,0 +1,74 @@ +# @package _global_ +# Phase floor for the 2D-benchmark slab3 ER/mito buckets (mitochondria_*__2d_focusslab3): the raw +# Phase3D input scored as the "prediction" (io.pred_is_source) on the same focus plane, with +# the same slab3 recipe and plane anchors. It is the no-model reference those focus-plane +# Dice values are compared against; the whole-volume floor stays in the canonical +# evaluations_with_embeddings/eval_phase_* dirs, re-rooted here under /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/. +# Generated by applications/dynacell/experiments/2026-10-06_2d-focus-slab3/make_floor_buckets.py. +target_name: mitochondria +compute_feature_metrics: false +compute_microssim: false +use_gpu: true +io: + require_complete_cache: false +pixel_metrics: + fsc: null + spectral_pcc: null +focus2d: + halfwidth: 1 +segmentation: + focus_anchor: nucleus_area + nuclei_channel_name: Nuclei +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +conditions: +- name: phase__no_model__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/ipsc/evaluations_with_embeddings/eval_phase_mitochondria +- name: phase__no_model__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/a549/evaluations_with_embeddings/eval_phase_mitochondria_mock + segmentation: + focus_anchor: phase_midband +- name: phase__no_model__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/a549/evaluations_with_embeddings/eval_phase_mitochondria_denv + segmentation: + focus_anchor: phase_midband +- name: phase__no_model__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_2d_focus_slab3/a549/evaluations_with_embeddings/eval_phase_mitochondria_zikv + segmentation: + focus_anchor: phase_midband diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus__2d_focus2d_pix2pix2d_wmatch/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus__2d_focus2d_pix2pix2d_wmatch/eval_grouped.yaml new file mode 100644 index 000000000..d78df9499 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus__2d_focus2d_pix2pix2d_wmatch/eval_grouped.yaml @@ -0,0 +1,189 @@ +# @package _global_ +# pix2pix2d warmup-matched refit: the pix2pix2d conditions of the nucleus +# 2D focus2d buckets (and seed1 bucket), on the pix2pix2d_unetvit_wmatch[_seed1] stores. +# Same recipe, planes and caches as those buckets. Written by +# applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +focus2d: + halfwidth: 1 +conditions: +- name: pix2pix2d_wmatch__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit_wmatch/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_wmatch/ipsc/a549__denv +- name: pix2pix2d_wmatch__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit_wmatch/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_wmatch/ipsc/a549__mock +- name: pix2pix2d_wmatch__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv +- name: pix2pix2d_wmatch__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/pix2pix2d_unetvit_wmatch/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_wmatch/ipsc/ipsc +- name: pix2pix2d_wmatch__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit_wmatch/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_wmatch/a549/a549__denv +- name: pix2pix2d_wmatch__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit_wmatch/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_wmatch/a549/a549__mock +- name: pix2pix2d_wmatch__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit_wmatch/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_wmatch/a549/a549__zikv +- name: pix2pix2d_wmatch__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/pix2pix2d_unetvit_wmatch/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_wmatch/a549/ipsc +- name: pix2pix2d_wmatch__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit_wmatch/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_wmatch/joint/a549__denv +- name: pix2pix2d_wmatch__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit_wmatch/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_wmatch/joint/a549__mock +- name: pix2pix2d_wmatch__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit_wmatch/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_wmatch/joint/a549__zikv +- name: pix2pix2d_wmatch__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/pix2pix2d_unetvit_wmatch/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_wmatch/joint/ipsc +- name: pix2pix2d_wmatch_seed1__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__denv +- name: pix2pix2d_wmatch_seed1__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__mock +- name: pix2pix2d_wmatch_seed1__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__zikv +- name: pix2pix2d_wmatch_seed1__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_bf_trained/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_bf_trained/eval_grouped.yaml new file mode 100644 index 000000000..03f9a1820 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_bf_trained/eval_grouped.yaml @@ -0,0 +1,97 @@ +# @package _global_ +# Grouped leaf: nucleus bucket, a549_bf_trained models (8 conditions). Auto-generated by tools/generate_grouped_eval_configs.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: celldiff_r2_iterative__a549_bf_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/a549__bf/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_r2_iterative/a549__bf/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/a549__bf/a549__denv +- name: fnet3d__a549_bf_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549__bf/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_paper/a549__bf/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549__bf/a549__denv +- name: celldiff_r2_iterative__a549_bf_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/a549__bf/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_r2_iterative/a549__bf/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/a549__bf/a549__mock +- name: fnet3d__a549_bf_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549__bf/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_paper/a549__bf/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549__bf/a549__mock +- name: celldiff_r2_iterative__a549_bf_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/a549__bf/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_r2_iterative/a549__bf/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/a549__bf/a549__zikv +- name: fnet3d__a549_bf_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549__bf/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_paper/a549__bf/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549__bf/a549__zikv +- name: celldiff_r2_iterative__a549_bf_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/a549__bf/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/celldiff_r2_iterative/a549__bf/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/a549__bf/ipsc +- name: fnet3d__a549_bf_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549__bf/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fnet3d_paper/a549__bf/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549__bf/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained/eval_grouped.yaml index 6d796c184..f6862f432 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained/eval_grouped.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained/eval_grouped.yaml @@ -13,7 +13,7 @@ force_recompute: final_metrics: true compute_instance_ap: true segmentation: - backend: cellpose + backend: cpdino conditions: - name: celldiff_r2__a549_trained__a549_denv benchmark: @@ -21,197 +21,197 @@ conditions: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_r2_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/celldiff_r2/h2b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_r2/a549/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/a549__denv - name: vscyto3d__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/h2b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/a549/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/a549__denv - name: unext2__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/h2b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/a549/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/a549__denv - name: fnet3d__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fnet3d_paper/h2b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_paper/a549/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/a549__denv - name: pix2pix3d__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit_a549trained__h2b_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/pix2pix3d_unetvit/h2b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix3d_unetvit/a549/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_pix2pix3d_a549trained_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__denv - name: celldiff_r2__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_r2_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/celldiff_r2/h2b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_r2/a549/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/a549__mock - name: vscyto3d__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/h2b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/a549/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/a549__mock - name: unext2__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/h2b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/a549/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/a549__mock - name: fnet3d__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fnet3d_paper/h2b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_paper/a549/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/a549__mock - name: pix2pix3d__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit_a549trained__h2b_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/pix2pix3d_unetvit/h2b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix3d_unetvit/a549/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_pix2pix3d_a549trained_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__mock - name: celldiff_r2__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_r2_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/celldiff_r2/h2b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_r2/a549/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/a549__zikv - name: vscyto3d__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/h2b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/a549/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/a549__zikv - name: unext2__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/h2b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/a549/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/a549__zikv - name: fnet3d__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/fnet3d_paper/h2b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_paper/a549/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/a549__zikv - name: pix2pix3d__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit_a549trained__h2b_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/a549_trained/pix2pix3d_unetvit/h2b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix3d_unetvit/a549/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_a549trained_with_embeddings/eval_pix2pix3d_a549trained_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__zikv - name: celldiff_r2__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_celldiff_r2_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/celldiff_r2/nucleus_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/celldiff_r2/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_celldiff_r2_a549trained_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/ipsc - name: vscyto3d__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fcmae_vscyto3d_pretrained_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/fcmae_vscyto3d_pretrained/nucleus_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_vscyto3d_a549trained_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/ipsc - name: unext2__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fcmae_vscyto3d_scratch_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/fcmae_vscyto3d_scratch/nucleus_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_unext2_a549trained_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/ipsc - name: fnet3d__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fnet3d_paper_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/fnet3d_paper/nucleus_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fnet3d_paper/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_fnet3d_a549trained_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/ipsc - name: pix2pix3d__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_pix2pix3d_unetvit_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/a549_trained/pix2pix3d_unetvit/nucleus_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/pix2pix3d_unetvit/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_a549trained_with_embeddings/eval_pix2pix3d_a549trained_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained__2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained__2d/eval_grouped.yaml new file mode 100644 index 000000000..89ceb7c62 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained__2d/eval_grouped.yaml @@ -0,0 +1,285 @@ +# @package _global_ +# Focused sibling of grouped/nucleus_a549_trained: ONLY the in-focus 2D conditions -- +# fnet2d + FCMAE-2D (unext2_2d, vscyto2d) + celldiff_2d + pix2pix2d +# x {ipsc, a549 mock/denv/zikv} = 20. +# Condition blocks are copied verbatim from a generate_grouped_eval_configs.py run, +# so they stay byte-identical to what the canonical bucket would emit -- only the +# selection is narrowed. +# +# celldiff_2d was folded in on 2026-08-04, once its predicts finished. It was held +# out until then because the generator's only freshness gate is pred_path.is_dir(), +# which passes on a partially-written store (measured 4813 of 5787 chunk files on a +# live nucleus/celldiff_2d/ipsc/a549__denv). The gate applied by hand instead was a +# per-store chunk count against the fnet2d store for the same organelle/pool/bucket, +# required to match exactly. The complete size is a property of (organelle, bucket), +# not a constant: 4270-4300 on the iPSC buckets and 5211-5787 on the A549 ones, and +# er/a549__denv is the low outlier at 5211 in EVERY pool. That one was confirmed +# against two further fully-evaluated models (both FCMAE-2D arms, also 5211, same 12 +# FOVs) so it is the true size and not a shortfall shared with the reference -- which +# a fnet2d-relative gate cannot see by itself. Plus sacct COMPLETED 0:0 on all 48 +# CELLDiff2D_PRED jobs. +# +# pix2pix2d was folded in on 2026-08-05, once its 48 predicts finished (all COMPLETED +# 0:0). Held out for the same reason, but gated harder than celldiff_2d was: per array, +# the expected chunk count = prod(ceil(shape / chunks)) read analytically from that +# array's own zarr.json, compared against the files actually present. That catches a +# truncated write inside a position without needing a reference family at all, which +# is what a fnet2d-relative count could not do. It is paired with a position-set +# comparison against a family already known complete, because a store missing whole +# FOVs is internally self-consistent and its own metadata can never reveal the gap. +# All 48 passed both checks: 100 positions per iPSC bucket, 12 per A549 bucket, every +# array fully chunked (.tmp/pix2pix2d/verify_predict_stores.py). +# +# Why a sibling instead of folding the 2D models into the canonical bucket: +# 1. The generator sets force_recompute.final_metrics: true, so the canonical +# bucket's already-evaluated 3D conditions would ALL recompute, not cache-skip. +# 2. Fairness. The global pixel metrics (PCC/SSIM/FSC/PSNR/Spectral_PCC), +# MicroMS3IM and the CP regionprops are computed over the FULL 3D volume, +# while per-cell similarity, the deep features (DINOv3/DynaCLR/CellDINO/ +# MorphEm) and instance AP are focus-restricted (pipeline.py). Only the +# focus-restricted families are a fair 2D-vs-3D comparison -- a per-z 2D model +# is penalised by the volume-reconstruction columns for planes it never +# targeted (2d-infocus-vs-models.md 1a). The full-3D columns are still +# computed here as diagnostics; they are NOT publishable as 2D-vs-3D. +# +# force_recompute: every pred_* artifact is forced, plus final_metrics. +# +# Until 2026-09-10 this block was `final_metrics: false`, on the grounds that 16 of +# the 20 conditions were already fully evaluated (verified 2026-08-05) and could +# cache-skip. That is now WRONG and the flag is inverted: an affine bug blanked the +# training data at z_window_size=1 (fixed in VisCy 9640537d), so 4 of the 5 2D +# families -- pix2pix2d, celldiff_2d and both FCMAE-2D arms -- were retrained from +# scratch and ALL 192 2D predictions were regenerated 2026-09-10..14. fnet2d is the +# only family that was never affected (flip-only augmentation). +# +# The prediction stores were rewritten IN PLACE with --overwrite, and the eval caches +# carry no prediction provenance -- nothing in the cache key changes when the pixels +# behind it change. So `final_metrics: true` alone is NOT enough: it would recompute +# the summary while still reading August's cached masks, instances and deep features. +# Every pred_* flag has to be forced for the numbers to reflect the new predictions. +# +# gt_* stays false deliberately. The ground truth did not change, and the GT-side deep +# features are the expensive half of a cold extraction. Do not set force_recompute.all +# -- it forces gt_* too (see _resolve_force in evaluation/pipeline_cache.py). +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: celldiff_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/a549__denv +- name: vscyto2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/a549__denv +- name: unext2_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/a549__denv +- name: fnet2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__denv +- name: pix2pix2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/a549__denv +- name: celldiff_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/a549__mock +- name: vscyto2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/a549__mock +- name: unext2_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/a549__mock +- name: fnet2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__mock +- name: pix2pix2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/a549__mock +- name: celldiff_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/a549__zikv +- name: vscyto2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/a549__zikv +- name: unext2_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/a549__zikv +- name: fnet2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__zikv +- name: pix2pix2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/a549__zikv +- name: celldiff_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/celldiff_2d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/ipsc +- name: vscyto2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/ipsc +- name: unext2_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/ipsc +- name: fnet2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fnet2d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/ipsc +- name: pix2pix2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/pix2pix2d_unetvit/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained__2d_focus2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained__2d_focus2d/eval_grouped.yaml new file mode 100644 index 000000000..d44735d76 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained__2d_focus2d/eval_grouped.yaml @@ -0,0 +1,234 @@ +# @package _global_ +# 2D benchmark (focus2d.halfwidth=1): every metric on one GT-anchored focus plane per +# FOV/timepoint -- pixel metrics, MicroMS3IM and CP on the plane, deep features and per-cell +# similarity on its 3-plane slab, instance masks (cpdino) on the slab MIP. The 3D benchmark +# keeps the full volume in the canonical dirs; this bucket never writes there (save_dir re- +# rooted under /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/). Conditions: +# the 20 of nucleus_a549_trained__2d (5 2D families x 4 test sets), predictions unchanged. +# Plane anchor: nucleus_area on the GT nucleus target (iPSC and A549). Caches: +# /focus2d_h1/ (GT and pred); CP reference __focus2d_h1. Generated by +# applications/dynacell/experiments/2026-10-07_2d-vs-3d-cost/make_focus2d_buckets.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +focus2d: + halfwidth: 1 +conditions: +- name: celldiff_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/celldiff_2d/a549/a549__denv +- name: vscyto2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_pretrained/a549/a549__denv +- name: unext2_2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_scratch/a549/a549__denv +- name: fnet2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fnet2d/a549/a549__denv +- name: pix2pix2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit/a549/a549__denv +- name: celldiff_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/celldiff_2d/a549/a549__mock +- name: vscyto2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_pretrained/a549/a549__mock +- name: unext2_2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_scratch/a549/a549__mock +- name: fnet2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fnet2d/a549/a549__mock +- name: pix2pix2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit/a549/a549__mock +- name: celldiff_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/celldiff_2d/a549/a549__zikv +- name: vscyto2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_pretrained/a549/a549__zikv +- name: unext2_2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_scratch/a549/a549__zikv +- name: fnet2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fnet2d/a549/a549__zikv +- name: pix2pix2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit/a549/a549__zikv +- name: celldiff_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/celldiff_2d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/celldiff_2d/a549/ipsc +- name: vscyto2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_pretrained/a549/ipsc +- name: unext2_2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_scratch/a549/ipsc +- name: fnet2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fnet2d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fnet2d/a549/ipsc +- name: pix2pix2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/pix2pix2d_unetvit/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained__lite/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained__lite/eval_grouped.yaml new file mode 100644 index 000000000..512d1d816 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained__lite/eval_grouped.yaml @@ -0,0 +1,182 @@ +# @package _global_ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained/eval_grouped.yaml. Do not edit; regenerate. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino +compute_microssim: false +feature_metrics: + compute_fid: false + compute_prc: false + compute_mind: false +conditions: +- name: celldiff_r2__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/celldiff_r2/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/a549/a549__denv +- name: vscyto3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/a549/a549__denv +- name: unext2__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/a549/a549__denv +- name: fnet3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/fnet3d_paper/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/a549/a549__denv +- name: celldiff_r2__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/celldiff_r2/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/a549/a549__mock +- name: vscyto3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/a549/a549__mock +- name: unext2__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/a549/a549__mock +- name: fnet3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/fnet3d_paper/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/a549/a549__mock +- name: celldiff_r2__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/celldiff_r2/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/a549/a549__zikv +- name: vscyto3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/a549/a549__zikv +- name: unext2__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/a549/a549__zikv +- name: fnet3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/fnet3d_paper/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/a549/a549__zikv +- name: celldiff_r2__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/nucleus/celldiff_r2/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/a549/ipsc +- name: vscyto3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/a549/ipsc +- name: unext2__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/a549/ipsc +- name: fnet3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/nucleus/fnet3d_paper/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained__temporal/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained__temporal/eval_grouped.yaml new file mode 100644 index 000000000..0c669a25e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_a549_trained__temporal/eval_grouped.yaml @@ -0,0 +1,95 @@ +# @package _global_ +# Focused sibling of grouped/nucleus_a549_trained: ONLY the 6 Phase 17 FNet3D +# temporal-sampling conditions (fnet3d_t01, fnet3d_tspread x a549 mock/denv/zikv). +# Condition blocks are copied verbatim from a generate_grouped_eval_configs.py run, +# so they stay byte-identical to what the canonical bucket would emit -- only the +# selection is narrowed. +# +# The two arms trained on equal frame budgets drawn differently in time: `t01` on +# timepoints {0,1} (hpi 5 and 7) only, `tspread` spread over the whole course. The +# A549 test set spans hpi 5->23, so these predicts are the ONLY valid cross-arm +# comparison: each arm validates on its own frame subset, which makes +# `loss/validate` incomparable across arms. Measured best-val bears this out -- +# nucleus favours t01 (0.027 vs 0.109) while ER favours tspread (0.747 vs 0.405), +# i.e. the ordering flips by organelle and means nothing. +# +# Why not run the canonical bucket: the generator sets +# force_recompute.final_metrics: true, so its already-evaluated conditions would +# all recompute instead of cache-skipping. +# +# All 6 conditions are brand new, so nothing is cached. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: fnet3d_t01__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_t01/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_t01/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_t01/a549/a549__denv +- name: fnet3d_tspread__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_tspread/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_tspread/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_tspread/a549/a549__denv +- name: fnet3d_t01__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_t01/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_t01/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_t01/a549/a549__mock +- name: fnet3d_tspread__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_tspread/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_tspread/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_tspread/a549/a549__mock +- name: fnet3d_t01__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_t01/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_t01/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_t01/a549/a549__zikv +- name: fnet3d_tspread__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_tspread/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_tspread/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_tspread/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_bf_trained/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_bf_trained/eval_grouped.yaml new file mode 100644 index 000000000..942b5ee50 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_bf_trained/eval_grouped.yaml @@ -0,0 +1,97 @@ +# @package _global_ +# Grouped leaf: nucleus bucket, ipsc_bf_trained models (8 conditions). Auto-generated by tools/generate_grouped_eval_configs.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: celldiff_r2_iterative__ipsc_bf_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc__bf/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_r2_iterative/ipsc__bf/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc__bf/a549__denv +- name: fnet3d__ipsc_bf_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc__bf/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_paper/ipsc__bf/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc__bf/a549__denv +- name: celldiff_r2_iterative__ipsc_bf_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc__bf/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_r2_iterative/ipsc__bf/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc__bf/a549__mock +- name: fnet3d__ipsc_bf_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc__bf/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_paper/ipsc__bf/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc__bf/a549__mock +- name: celldiff_r2_iterative__ipsc_bf_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc__bf/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_r2_iterative/ipsc__bf/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc__bf/a549__zikv +- name: fnet3d__ipsc_bf_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc__bf/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_paper/ipsc__bf/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc__bf/a549__zikv +- name: celldiff_r2_iterative__ipsc_bf_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc__bf/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/celldiff_r2_iterative/ipsc__bf/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc__bf/ipsc +- name: fnet3d__ipsc_bf_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc__bf/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fnet3d_paper/ipsc__bf/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc__bf/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_bf_trained__patchaug/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_bf_trained__patchaug/eval_grouped.yaml new file mode 100644 index 000000000..5f06ad2a5 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_bf_trained__patchaug/eval_grouped.yaml @@ -0,0 +1,113 @@ +# @package _global_ +# Focused sibling of grouped/nucleus_ipsc_bf_trained: ONLY the 8 brightfield +# patch-vs-augmentation conditions (fnet3d_bigpatch, fnet3d_vscyto3daug x +# {ipsc, a549 mock/denv/zikv}). Condition blocks are copied verbatim from a +# generate_grouped_eval_configs.py run, so they stay byte-identical to what the +# canonical bucket would emit -- only the selection is narrowed. +# +# These arms close the gap the brightfield readout left open: the published bf +# comparison ran on FNet3D's own recipe, which sec:fnet_patch_aug_ablation shows +# is the broken rung, so brightfield on a healthy recipe was never measured. +# +# Why not just run the canonical 16-condition bucket: the generator sets +# force_recompute.final_metrics: true, so the 8 already-evaluated bf conditions +# (celldiff_r2_iterative, fnet3d_paper) would NOT cache-skip -- they would all +# recompute, and re-scoring published numbers under a possibly different metric +# pin is a researcher decision, not a side effect of adding two arms. +# +# All 8 conditions are brand new, so nothing is cached. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: fnet3d_bigpatch__ipsc_bf_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc__bf/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_bigpatch/ipsc__bf/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc__bf/a549__denv +- name: fnet3d_vscyto3daug__ipsc_bf_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc__bf/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_vscyto3daug/ipsc__bf/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc__bf/a549__denv +- name: fnet3d_bigpatch__ipsc_bf_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc__bf/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_bigpatch/ipsc__bf/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc__bf/a549__mock +- name: fnet3d_vscyto3daug__ipsc_bf_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc__bf/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_vscyto3daug/ipsc__bf/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc__bf/a549__mock +- name: fnet3d_bigpatch__ipsc_bf_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc__bf/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_bigpatch/ipsc__bf/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc__bf/a549__zikv +- name: fnet3d_vscyto3daug__ipsc_bf_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc__bf/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_vscyto3daug/ipsc__bf/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc__bf/a549__zikv +- name: fnet3d_bigpatch__ipsc_bf_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc__bf/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fnet3d_bigpatch/ipsc__bf/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc__bf/ipsc +- name: fnet3d_vscyto3daug__ipsc_bf_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc__bf/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fnet3d_vscyto3daug/ipsc__bf/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc__bf/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained/eval_grouped.yaml index 3b9cf2744..14e705a15 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained/eval_grouped.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained/eval_grouped.yaml @@ -13,7 +13,7 @@ force_recompute: final_metrics: true compute_instance_ap: true segmentation: - backend: cellpose + backend: cpdino conditions: - name: celldiff_r2_iterative__ipsc_trained__a549_denv benchmark: @@ -21,257 +21,257 @@ conditions: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_r2_iterative_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/h2b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_r2_iterative/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_celldiff_r2_iterative_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/a549__denv - name: vscyto3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/h2b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__denv - name: unext2__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/h2b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unext2_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__denv - name: fnet3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fnet3d_paper/h2b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_paper/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_fnet3d_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/a549__denv - name: pix2pix3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit__h2b_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/pix2pix3d_unetvit/h2b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix3d_unetvit/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_pix2pix3d_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__denv - name: unetvit3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucleus_unetvit3d_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/unetvit3d/h2b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/unetvit3d/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unetvit3d_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/a549__denv - name: celldiff_r2_iterative__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_r2_iterative_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/h2b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_r2_iterative/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_celldiff_r2_iterative_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/a549__mock - name: vscyto3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/h2b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__mock - name: unext2__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/h2b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unext2_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__mock - name: fnet3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fnet3d_paper/h2b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_paper/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_fnet3d_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/a549__mock - name: pix2pix3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit__h2b_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/pix2pix3d_unetvit/h2b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix3d_unetvit/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_pix2pix3d_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__mock - name: unetvit3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucleus_unetvit3d_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/unetvit3d/h2b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/unetvit3d/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unetvit3d_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/a549__mock - name: celldiff_r2_iterative__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_r2_iterative_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/h2b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_r2_iterative/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_celldiff_r2_iterative_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/a549__zikv - name: vscyto3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/h2b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__zikv - name: unext2__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/h2b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unext2_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__zikv - name: fnet3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/fnet3d_paper/h2b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_paper/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_fnet3d_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/a549__zikv - name: pix2pix3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit__h2b_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/pix2pix3d_unetvit/h2b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix3d_unetvit/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_pix2pix3d_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__zikv - name: unetvit3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucleus_unetvit3d_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/ipsc_trained/unetvit3d/h2b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/unetvit3d/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_unetvit3d_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/a549__zikv - name: celldiff_r2_denoise__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_celldiff_r2_denoise.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/celldiff_r2_denoise/nucleus_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_denoise/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/celldiff_r2_denoise/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_celldiff_r2_denoise_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_denoise/ipsc/ipsc - name: celldiff_r2_iterative__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_celldiff_r2_iterative.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/celldiff_r2_iterative/nucleus_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/celldiff_r2_iterative/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_celldiff_r2_iterative_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/ipsc - name: celldiff_r2_sliding_window__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_celldiff_r2_sliding_window.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/celldiff_r2_sliding_window/nucleus_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_sliding_window/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/celldiff_r2_sliding_window/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_celldiff_r2_sliding_window_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_sliding_window/ipsc/ipsc - name: vscyto3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fcmae_vscyto3d_pretrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_pretrained/nucleus_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_vscyto3d_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/ipsc - name: unext2__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fcmae_vscyto3d_scratch.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/fcmae_vscyto3d_scratch/nucleus_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_unext2_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/ipsc - name: fnet3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fnet3d_paper.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/fnet3d_paper/nucleus_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fnet3d_paper/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_fnet3d_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/ipsc - name: pix2pix3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_pix2pix3d_unetvit.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/pix2pix3d_unetvit/nucleus_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/pix2pix3d_unetvit/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_pix2pix3d_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/ipsc - name: unetvit3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_unetvit3d.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/ipsc_trained/unetvit3d/nucleus_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/unetvit3d/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_unetvit3d_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d/eval_grouped.yaml new file mode 100644 index 000000000..c1f53dcc2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d/eval_grouped.yaml @@ -0,0 +1,285 @@ +# @package _global_ +# Focused sibling of grouped/nucleus_ipsc_trained: ONLY the in-focus 2D conditions -- +# fnet2d + FCMAE-2D (unext2_2d, vscyto2d) + celldiff_2d + pix2pix2d +# x {ipsc, a549 mock/denv/zikv} = 20. +# Condition blocks are copied verbatim from a generate_grouped_eval_configs.py run, +# so they stay byte-identical to what the canonical bucket would emit -- only the +# selection is narrowed. +# +# celldiff_2d was folded in on 2026-08-04, once its predicts finished. It was held +# out until then because the generator's only freshness gate is pred_path.is_dir(), +# which passes on a partially-written store (measured 4813 of 5787 chunk files on a +# live nucleus/celldiff_2d/ipsc/a549__denv). The gate applied by hand instead was a +# per-store chunk count against the fnet2d store for the same organelle/pool/bucket, +# required to match exactly. The complete size is a property of (organelle, bucket), +# not a constant: 4270-4300 on the iPSC buckets and 5211-5787 on the A549 ones, and +# er/a549__denv is the low outlier at 5211 in EVERY pool. That one was confirmed +# against two further fully-evaluated models (both FCMAE-2D arms, also 5211, same 12 +# FOVs) so it is the true size and not a shortfall shared with the reference -- which +# a fnet2d-relative gate cannot see by itself. Plus sacct COMPLETED 0:0 on all 48 +# CELLDiff2D_PRED jobs. +# +# pix2pix2d was folded in on 2026-08-05, once its 48 predicts finished (all COMPLETED +# 0:0). Held out for the same reason, but gated harder than celldiff_2d was: per array, +# the expected chunk count = prod(ceil(shape / chunks)) read analytically from that +# array's own zarr.json, compared against the files actually present. That catches a +# truncated write inside a position without needing a reference family at all, which +# is what a fnet2d-relative count could not do. It is paired with a position-set +# comparison against a family already known complete, because a store missing whole +# FOVs is internally self-consistent and its own metadata can never reveal the gap. +# All 48 passed both checks: 100 positions per iPSC bucket, 12 per A549 bucket, every +# array fully chunked (.tmp/pix2pix2d/verify_predict_stores.py). +# +# Why a sibling instead of folding the 2D models into the canonical bucket: +# 1. The generator sets force_recompute.final_metrics: true, so the canonical +# bucket's already-evaluated 3D conditions would ALL recompute, not cache-skip. +# 2. Fairness. The global pixel metrics (PCC/SSIM/FSC/PSNR/Spectral_PCC), +# MicroMS3IM and the CP regionprops are computed over the FULL 3D volume, +# while per-cell similarity, the deep features (DINOv3/DynaCLR/CellDINO/ +# MorphEm) and instance AP are focus-restricted (pipeline.py). Only the +# focus-restricted families are a fair 2D-vs-3D comparison -- a per-z 2D model +# is penalised by the volume-reconstruction columns for planes it never +# targeted (2d-infocus-vs-models.md 1a). The full-3D columns are still +# computed here as diagnostics; they are NOT publishable as 2D-vs-3D. +# +# force_recompute: every pred_* artifact is forced, plus final_metrics. +# +# Until 2026-09-10 this block was `final_metrics: false`, on the grounds that 16 of +# the 20 conditions were already fully evaluated (verified 2026-08-05) and could +# cache-skip. That is now WRONG and the flag is inverted: an affine bug blanked the +# training data at z_window_size=1 (fixed in VisCy 9640537d), so 4 of the 5 2D +# families -- pix2pix2d, celldiff_2d and both FCMAE-2D arms -- were retrained from +# scratch and ALL 192 2D predictions were regenerated 2026-09-10..14. fnet2d is the +# only family that was never affected (flip-only augmentation). +# +# The prediction stores were rewritten IN PLACE with --overwrite, and the eval caches +# carry no prediction provenance -- nothing in the cache key changes when the pixels +# behind it change. So `final_metrics: true` alone is NOT enough: it would recompute +# the summary while still reading August's cached masks, instances and deep features. +# Every pred_* flag has to be forced for the numbers to reflect the new predictions. +# +# gt_* stays false deliberately. The ground truth did not change, and the GT-side deep +# features are the expensive half of a cold extraction. Do not set force_recompute.all +# -- it forces gt_* too (see _resolve_force in evaluation/pipeline_cache.py). +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: celldiff_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/a549__denv +- name: vscyto2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__denv +- name: unext2_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__denv +- name: fnet2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__denv +- name: pix2pix2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/a549__denv +- name: celldiff_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/a549__mock +- name: vscyto2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__mock +- name: unext2_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__mock +- name: fnet2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__mock +- name: pix2pix2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/a549__mock +- name: celldiff_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/a549__zikv +- name: vscyto2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__zikv +- name: unext2_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__zikv +- name: fnet2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__zikv +- name: pix2pix2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/a549__zikv +- name: celldiff_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/celldiff_2d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/ipsc +- name: vscyto2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/ipsc +- name: unext2_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/ipsc +- name: fnet2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fnet2d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/ipsc +- name: pix2pix2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/pix2pix2d_unetvit/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d_focus2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d_focus2d/eval_grouped.yaml new file mode 100644 index 000000000..25512b96b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d_focus2d/eval_grouped.yaml @@ -0,0 +1,234 @@ +# @package _global_ +# 2D benchmark (focus2d.halfwidth=1): every metric on one GT-anchored focus plane per +# FOV/timepoint -- pixel metrics, MicroMS3IM and CP on the plane, deep features and per-cell +# similarity on its 3-plane slab, instance masks (cpdino) on the slab MIP. The 3D benchmark +# keeps the full volume in the canonical dirs; this bucket never writes there (save_dir re- +# rooted under /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/). Conditions: +# the 20 of nucleus_ipsc_trained__2d (5 2D families x 4 test sets), predictions unchanged. +# Plane anchor: nucleus_area on the GT nucleus target (iPSC and A549). Caches: +# /focus2d_h1/ (GT and pred); CP reference __focus2d_h1. Generated by +# applications/dynacell/experiments/2026-10-07_2d-vs-3d-cost/make_focus2d_buckets.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +focus2d: + halfwidth: 1 +conditions: +- name: celldiff_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/celldiff_2d/ipsc/a549__denv +- name: vscyto2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__denv +- name: unext2_2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__denv +- name: fnet2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fnet2d/ipsc/a549__denv +- name: pix2pix2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit/ipsc/a549__denv +- name: celldiff_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/celldiff_2d/ipsc/a549__mock +- name: vscyto2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__mock +- name: unext2_2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__mock +- name: fnet2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fnet2d/ipsc/a549__mock +- name: pix2pix2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit/ipsc/a549__mock +- name: celldiff_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/celldiff_2d/ipsc/a549__zikv +- name: vscyto2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__zikv +- name: unext2_2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__zikv +- name: fnet2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fnet2d/ipsc/a549__zikv +- name: pix2pix2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit/ipsc/a549__zikv +- name: celldiff_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/celldiff_2d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/celldiff_2d/ipsc/ipsc +- name: vscyto2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_pretrained/ipsc/ipsc +- name: unext2_2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_scratch/ipsc/ipsc +- name: fnet2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fnet2d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fnet2d/ipsc/ipsc +- name: pix2pix2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/pix2pix2d_unetvit/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d_focus2d_seed1/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d_focus2d_seed1/eval_grouped.yaml new file mode 100644 index 000000000..6f3085f64 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d_focus2d_seed1/eval_grouped.yaml @@ -0,0 +1,197 @@ +# @package _global_ +# 2D benchmark (focus2d.halfwidth=1): every metric on one GT-anchored focus plane per +# FOV/timepoint -- pixel metrics, MicroMS3IM and CP on the plane, deep features and per-cell +# similarity on its 3-plane slab, instance masks (cpdino) on the slab MIP. The 3D benchmark +# keeps the full volume in the canonical dirs; this bucket never writes there (save_dir re- +# rooted under /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/). Conditions: +# the 20 of nucleus_ipsc_trained__2d (5 2D families x 4 test sets), predictions unchanged. +# Plane anchor: nucleus_area on the GT nucleus target (iPSC and A549). Caches: +# /focus2d_h1/ (GT and pred); CP reference __focus2d_h1. Generated by +# applications/dynacell/experiments/2026-10-07_2d-vs-3d-cost/make_focus2d_buckets.py. +# Seed replicates: the 16 conditions of nucleus_ipsc_trained__2d_focus2d whose family has a +# seed1 fit (VSCyto2D has none), on the _seed1 stores. Generated by +# applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_seed_buckets.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +focus2d: + halfwidth: 1 +conditions: +- name: celldiff_2d_seed1__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d_seed1/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d_seed1/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/celldiff_2d_seed1/ipsc/a549__denv +- name: unext2_2d_seed1__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/a549__denv +- name: fnet2d_seed1__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_seed1/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d_seed1/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fnet2d_seed1/ipsc/a549__denv +- name: pix2pix2d_seed1__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_seed1/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit_seed1/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_seed1/ipsc/a549__denv +- name: celldiff_2d_seed1__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d_seed1/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d_seed1/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/celldiff_2d_seed1/ipsc/a549__mock +- name: unext2_2d_seed1__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/a549__mock +- name: fnet2d_seed1__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_seed1/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d_seed1/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fnet2d_seed1/ipsc/a549__mock +- name: pix2pix2d_seed1__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_seed1/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit_seed1/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_seed1/ipsc/a549__mock +- name: celldiff_2d_seed1__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d_seed1/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d_seed1/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/celldiff_2d_seed1/ipsc/a549__zikv +- name: unext2_2d_seed1__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/a549__zikv +- name: fnet2d_seed1__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_seed1/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d_seed1/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fnet2d_seed1/ipsc/a549__zikv +- name: pix2pix2d_seed1__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_seed1/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit_seed1/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_seed1/ipsc/a549__zikv +- name: celldiff_2d_seed1__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d_seed1/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/celldiff_2d_seed1/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/celldiff_2d_seed1/ipsc/ipsc +- name: unext2_2d_seed1__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/ipsc +- name: fnet2d_seed1__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_seed1/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fnet2d_seed1/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fnet2d_seed1/ipsc/ipsc +- name: pix2pix2d_seed1__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_seed1/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/pix2pix2d_unetvit_seed1/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit_seed1/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d_samplematched/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d_samplematched/eval_grouped.yaml new file mode 100644 index 000000000..40df4fc4f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d_samplematched/eval_grouped.yaml @@ -0,0 +1,80 @@ +# @package _global_ +# Focused sibling of grouped/nucleus_ipsc_trained__2d: ONLY the sample-matched +# UNeXt2-2D ablation arm (fcmae_vscyto2d_scratch_samplematched: the 3D fit's +# optimizer budget, 128 samples/step, warmup 8500, 3D cosine horizon) +# x {ipsc, a549 mock/denv/zikv} = 4. +# Condition blocks come from generate_grouped_eval_configs.py's own parse_zarr_name + +# build_leaf_yaml, fed the output_store of each predict leaf in +# nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/ (built by +# experiments/2026-09-29_unext2-2d-samplematched/build_eval_buckets.py). +# +# Top-level settings, including force_recompute, are copied from the __2d sibling so +# the arm is scored exactly as its fcmae_vscyto2d_scratch baseline was. Compare on +# the focus-restricted metrics only; the full-3D columns are diagnostics (see the +# __2d leaf header). +# +# GATE before running: pred_path.is_dir() passes on a half-written store. Require +# sacct COMPLETED 0:0 on all predicts AND per-array chunk counts equal to +# prod(ceil(shape / chunks)) AND the position set equal to the baseline store's. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: unext2_2d_samplematched__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__denv +- name: unext2_2d_samplematched__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__mock +- name: unext2_2d_samplematched__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__zikv +- name: unext2_2d_samplematched__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d_voxelmatched/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d_voxelmatched/eval_grouped.yaml new file mode 100644 index 000000000..5212cda8c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__2d_voxelmatched/eval_grouped.yaml @@ -0,0 +1,79 @@ +# @package _global_ +# Focused sibling of grouped/nucleus_ipsc_trained__2d: ONLY the voxel-matched +# FNet-2D ablation arm (fnet2d_voxelmatched, batch 48 -> 1536 = fnet3d_paper's +# planes/step) x {ipsc, a549 mock/denv/zikv} = 4. +# Condition blocks come from generate_grouped_eval_configs.py's own parse_zarr_name + +# build_leaf_yaml, fed the output_store of each predict leaf in +# nucleus/fnet2d_voxelmatched/ipsc_confocal/ (built by +# experiments/2026-09-24_fnet2d-voxelmatched-smoke/build_eval_buckets.py). +# +# Top-level settings, including force_recompute, are copied from the __2d sibling so +# the arm is scored exactly as its fnet2d baseline was. Compare on the +# focus-restricted metrics only; the full-3D columns are diagnostics (see the __2d +# leaf header). +# +# GATE before running: pred_path.is_dir() passes on a half-written store. Require +# sacct COMPLETED 0:0 on all predicts AND per-array chunk counts equal to +# prod(ceil(shape / chunks)) AND the position set equal to the fnet2d sibling store's. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: fnet2d_voxelmatched__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_voxelmatched/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d_voxelmatched/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_voxelmatched/ipsc/a549__denv +- name: fnet2d_voxelmatched__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_voxelmatched/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d_voxelmatched/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_voxelmatched/ipsc/a549__mock +- name: fnet2d_voxelmatched__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_voxelmatched/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d_voxelmatched/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_voxelmatched/ipsc/a549__zikv +- name: fnet2d_voxelmatched__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_voxelmatched/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fnet2d_voxelmatched/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_voxelmatched/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__lite/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__lite/eval_grouped.yaml new file mode 100644 index 000000000..ae8a1d0e7 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__lite/eval_grouped.yaml @@ -0,0 +1,222 @@ +# @package _global_ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained/eval_grouped.yaml. Do not edit; regenerate. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino +compute_microssim: false +feature_metrics: + compute_fid: false + compute_prc: false + compute_mind: false +conditions: +- name: celldiff_r2_iterative__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/celldiff_r2_iterative/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2_iterative/ipsc/a549__denv +- name: vscyto3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__denv +- name: unext2__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__denv +- name: fnet3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/fnet3d_paper/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/ipsc/a549__denv +- name: unetvit3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/unetvit3d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/unetvit3d/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/unetvit3d/ipsc/a549__denv +- name: celldiff_r2_iterative__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/celldiff_r2_iterative/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2_iterative/ipsc/a549__mock +- name: vscyto3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__mock +- name: unext2__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__mock +- name: fnet3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/fnet3d_paper/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/ipsc/a549__mock +- name: unetvit3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/unetvit3d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/unetvit3d/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/unetvit3d/ipsc/a549__mock +- name: celldiff_r2_iterative__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/celldiff_r2_iterative/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2_iterative/ipsc/a549__zikv +- name: vscyto3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__zikv +- name: unext2__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__zikv +- name: fnet3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/fnet3d_paper/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/ipsc/a549__zikv +- name: unetvit3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/unetvit3d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/unetvit3d/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/unetvit3d/ipsc/a549__zikv +- name: celldiff_r2_iterative__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/nucleus/celldiff_r2_iterative/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2_iterative/ipsc/ipsc +- name: vscyto3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/ipsc/ipsc +- name: unext2__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/ipsc/ipsc +- name: fnet3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/nucleus/fnet3d_paper/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/ipsc/ipsc +- name: unetvit3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/unetvit3d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/nucleus/unetvit3d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/unetvit3d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__patchaug/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__patchaug/eval_grouped.yaml new file mode 100644 index 000000000..33838896b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_ipsc_trained__patchaug/eval_grouped.yaml @@ -0,0 +1,113 @@ +# @package _global_ +# Focused sibling of grouped/nucleus_ipsc_trained: ONLY the 8 Phase 15 +# patch-vs-augmentation conditions (fnet3d_bigpatch, fnet3d_vscyto3daug x +# {ipsc, a549 mock/denv/zikv}). Condition blocks are copied verbatim from a +# generate_grouped_eval_configs.py run, so they stay byte-identical to what the +# canonical bucket would emit -- only the selection is narrowed. +# +# Why not just run the canonical 38-condition bucket: +# 1. The generator sets force_recompute.final_metrics: true, so the 26 already- +# evaluated conditions would NOT cache-skip -- they would all recompute. +# 2. Regenerating the canonical leaves also folds in 4 `fnet2d` conditions per +# bucket. The 2D track is supposed to be reported only on focus-restricted +# metrics (a per-z 2D model is penalised for planes it never targeted by the +# full-3D volume-reconstruction metrics), so scoring it here would manufacture +# numbers that must not be published. That folding is a researcher decision, +# not a side effect of the Phase 15 predicts. +# +# All 8 conditions are brand new, so nothing is cached. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: fnet3d_bigpatch__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_bigpatch/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/a549__denv +- name: fnet3d_vscyto3daug__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_vscyto3daug/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/a549__denv +- name: fnet3d_bigpatch__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_bigpatch/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/a549__mock +- name: fnet3d_vscyto3daug__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_vscyto3daug/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/a549__mock +- name: fnet3d_bigpatch__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_bigpatch/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/a549__zikv +- name: fnet3d_vscyto3daug__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_vscyto3daug/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/a549__zikv +- name: fnet3d_bigpatch__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fnet3d_bigpatch/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/ipsc +- name: fnet3d_vscyto3daug__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fnet3d_vscyto3daug/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_joint/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_joint/eval_grouped.yaml index d0d41273b..c5fc4a653 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_joint/eval_grouped.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_joint/eval_grouped.yaml @@ -13,7 +13,7 @@ force_recompute: final_metrics: true compute_instance_ap: true segmentation: - backend: cellpose + backend: cpdino conditions: - name: celldiff_r2__joint__a549_denv benchmark: @@ -21,197 +21,197 @@ conditions: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_celldiff_r2_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/celldiff_r2/h2b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_r2/joint/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/a549__denv - name: vscyto3d__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/h2b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/joint/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/a549__denv - name: unext2__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_fcmae_vscyto3d_scratch_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_scratch/h2b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/joint/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/a549__denv - name: fnet3d__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_fnet3d_paper_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fnet3d_paper/h2b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_paper/joint/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/a549__denv - name: pix2pix3d__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_pix2pix3d_unetvit__h2b_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/pix2pix3d_unetvit/h2b_denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix3d_unetvit/joint/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_pix2pix3d_jointtrained_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__denv - name: celldiff_r2__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_celldiff_r2_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/celldiff_r2/h2b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_r2/joint/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/a549__mock - name: vscyto3d__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/h2b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/joint/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/a549__mock - name: unext2__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_fcmae_vscyto3d_scratch_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_scratch/h2b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/joint/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/a549__mock - name: fnet3d__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_fnet3d_paper_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fnet3d_paper/h2b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_paper/joint/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/a549__mock - name: pix2pix3d__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_pix2pix3d_unetvit__h2b_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/pix2pix3d_unetvit/h2b_mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix3d_unetvit/joint/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_pix2pix3d_jointtrained_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__mock - name: celldiff_r2__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_celldiff_r2_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/celldiff_r2/h2b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_r2/joint/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/a549__zikv - name: vscyto3d__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/h2b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/joint/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/a549__zikv - name: unext2__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_fcmae_vscyto3d_scratch_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fcmae_vscyto3d_scratch/h2b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/joint/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/a549__zikv - name: fnet3d__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_fnet3d_paper_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/fnet3d_paper/h2b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet3d_paper/joint/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/a549__zikv - name: pix2pix3d__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_pix2pix3d_unetvit__h2b_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/joint/pix2pix3d_unetvit/h2b_zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix3d_unetvit/joint/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_jointtrained_with_embeddings/eval_pix2pix3d_jointtrained_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__zikv - name: celldiff_r2__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/nucl_celldiff_r2.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/celldiff_r2/nucleus_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/celldiff_r2/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_celldiff_r2_jointtrained_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/ipsc - name: vscyto3d__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fcmae_vscyto3d_pretrained_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/fcmae_vscyto3d_pretrained/nucleus_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto3d_pretrained/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_vscyto3d_jointtrained_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/ipsc - name: unext2__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/nucl_fcmae_vscyto3d_scratch_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/fcmae_vscyto3d_scratch/nucleus_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto3d_scratch/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_unext2_jointtrained_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/ipsc - name: fnet3d__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/nucl_fnet3d_paper_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/fnet3d_paper/nucleus_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fnet3d_paper/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_fnet3d_jointtrained_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/ipsc - name: pix2pix3d__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/nucl_pix2pix3d_unetvit.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/joint/pix2pix3d_unetvit/nucleus_ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/pix2pix3d_unetvit/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_jointtrained_with_embeddings/eval_pix2pix3d_jointtrained_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_joint__2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_joint__2d/eval_grouped.yaml new file mode 100644 index 000000000..b3368fea1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_joint__2d/eval_grouped.yaml @@ -0,0 +1,285 @@ +# @package _global_ +# Focused sibling of grouped/nucleus_joint: ONLY the in-focus 2D conditions -- +# fnet2d + FCMAE-2D (unext2_2d, vscyto2d) + celldiff_2d + pix2pix2d +# x {ipsc, a549 mock/denv/zikv} = 20. +# Condition blocks are copied verbatim from a generate_grouped_eval_configs.py run, +# so they stay byte-identical to what the canonical bucket would emit -- only the +# selection is narrowed. +# +# celldiff_2d was folded in on 2026-08-04, once its predicts finished. It was held +# out until then because the generator's only freshness gate is pred_path.is_dir(), +# which passes on a partially-written store (measured 4813 of 5787 chunk files on a +# live nucleus/celldiff_2d/ipsc/a549__denv). The gate applied by hand instead was a +# per-store chunk count against the fnet2d store for the same organelle/pool/bucket, +# required to match exactly. The complete size is a property of (organelle, bucket), +# not a constant: 4270-4300 on the iPSC buckets and 5211-5787 on the A549 ones, and +# er/a549__denv is the low outlier at 5211 in EVERY pool. That one was confirmed +# against two further fully-evaluated models (both FCMAE-2D arms, also 5211, same 12 +# FOVs) so it is the true size and not a shortfall shared with the reference -- which +# a fnet2d-relative gate cannot see by itself. Plus sacct COMPLETED 0:0 on all 48 +# CELLDiff2D_PRED jobs. +# +# pix2pix2d was folded in on 2026-08-05, once its 48 predicts finished (all COMPLETED +# 0:0). Held out for the same reason, but gated harder than celldiff_2d was: per array, +# the expected chunk count = prod(ceil(shape / chunks)) read analytically from that +# array's own zarr.json, compared against the files actually present. That catches a +# truncated write inside a position without needing a reference family at all, which +# is what a fnet2d-relative count could not do. It is paired with a position-set +# comparison against a family already known complete, because a store missing whole +# FOVs is internally self-consistent and its own metadata can never reveal the gap. +# All 48 passed both checks: 100 positions per iPSC bucket, 12 per A549 bucket, every +# array fully chunked (.tmp/pix2pix2d/verify_predict_stores.py). +# +# Why a sibling instead of folding the 2D models into the canonical bucket: +# 1. The generator sets force_recompute.final_metrics: true, so the canonical +# bucket's already-evaluated 3D conditions would ALL recompute, not cache-skip. +# 2. Fairness. The global pixel metrics (PCC/SSIM/FSC/PSNR/Spectral_PCC), +# MicroMS3IM and the CP regionprops are computed over the FULL 3D volume, +# while per-cell similarity, the deep features (DINOv3/DynaCLR/CellDINO/ +# MorphEm) and instance AP are focus-restricted (pipeline.py). Only the +# focus-restricted families are a fair 2D-vs-3D comparison -- a per-z 2D model +# is penalised by the volume-reconstruction columns for planes it never +# targeted (2d-infocus-vs-models.md 1a). The full-3D columns are still +# computed here as diagnostics; they are NOT publishable as 2D-vs-3D. +# +# force_recompute: every pred_* artifact is forced, plus final_metrics. +# +# Until 2026-09-10 this block was `final_metrics: false`, on the grounds that 16 of +# the 20 conditions were already fully evaluated (verified 2026-08-05) and could +# cache-skip. That is now WRONG and the flag is inverted: an affine bug blanked the +# training data at z_window_size=1 (fixed in VisCy 9640537d), so 4 of the 5 2D +# families -- pix2pix2d, celldiff_2d and both FCMAE-2D arms -- were retrained from +# scratch and ALL 192 2D predictions were regenerated 2026-09-10..14. fnet2d is the +# only family that was never affected (flip-only augmentation). +# +# The prediction stores were rewritten IN PLACE with --overwrite, and the eval caches +# carry no prediction provenance -- nothing in the cache key changes when the pixels +# behind it change. So `final_metrics: true` alone is NOT enough: it would recompute +# the summary while still reading August's cached masks, instances and deep features. +# Every pred_* flag has to be forced for the numbers to reflect the new predictions. +# +# gt_* stays false deliberately. The ground truth did not change, and the GT-side deep +# features are the expensive half of a cold extraction. Do not set force_recompute.all +# -- it forces gt_* too (see _resolve_force in evaluation/pipeline_cache.py). +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: celldiff_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/a549__denv +- name: vscyto2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/a549__denv +- name: unext2_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/a549__denv +- name: fnet2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__denv +- name: pix2pix2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/a549__denv +- name: celldiff_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/a549__mock +- name: vscyto2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/a549__mock +- name: unext2_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/a549__mock +- name: fnet2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__mock +- name: pix2pix2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/a549__mock +- name: celldiff_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/a549__zikv +- name: vscyto2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/a549__zikv +- name: unext2_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/a549__zikv +- name: fnet2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__zikv +- name: pix2pix2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/a549__zikv +- name: celldiff_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/celldiff_2d/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/ipsc +- name: vscyto2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/ipsc +- name: unext2_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/ipsc +- name: fnet2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fnet2d/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/ipsc +- name: pix2pix2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/pix2pix2d_unetvit/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_joint__2d_focus2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_joint__2d_focus2d/eval_grouped.yaml new file mode 100644 index 000000000..779b9b46a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_joint__2d_focus2d/eval_grouped.yaml @@ -0,0 +1,234 @@ +# @package _global_ +# 2D benchmark (focus2d.halfwidth=1): every metric on one GT-anchored focus plane per +# FOV/timepoint -- pixel metrics, MicroMS3IM and CP on the plane, deep features and per-cell +# similarity on its 3-plane slab, instance masks (cpdino) on the slab MIP. The 3D benchmark +# keeps the full volume in the canonical dirs; this bucket never writes there (save_dir re- +# rooted under /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/). Conditions: +# the 20 of nucleus_joint__2d (5 2D families x 4 test sets), predictions unchanged. Plane +# anchor: nucleus_area on the GT nucleus target (iPSC and A549). Caches: +# /focus2d_h1/ (GT and pred); CP reference __focus2d_h1. Generated by +# applications/dynacell/experiments/2026-10-07_2d-vs-3d-cost/make_focus2d_buckets.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +focus2d: + halfwidth: 1 +conditions: +- name: celldiff_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/celldiff_2d/joint/a549__denv +- name: vscyto2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_pretrained/joint/a549__denv +- name: unext2_2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_scratch/joint/a549__denv +- name: fnet2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fnet2d/joint/a549__denv +- name: pix2pix2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit/joint/a549__denv +- name: celldiff_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/celldiff_2d/joint/a549__mock +- name: vscyto2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_pretrained/joint/a549__mock +- name: unext2_2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_scratch/joint/a549__mock +- name: fnet2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fnet2d/joint/a549__mock +- name: pix2pix2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit/joint/a549__mock +- name: celldiff_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/celldiff_2d/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/celldiff_2d/joint/a549__zikv +- name: vscyto2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_pretrained/joint/a549__zikv +- name: unext2_2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_scratch/joint/a549__zikv +- name: fnet2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/fnet2d/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fnet2d/joint/a549__zikv +- name: pix2pix2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix2d_unetvit/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit/joint/a549__zikv +- name: celldiff_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/celldiff_2d/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/celldiff_2d/joint/ipsc +- name: vscyto2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto2d_pretrained/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_pretrained/joint/ipsc +- name: unext2_2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fcmae_vscyto2d_scratch/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fcmae_vscyto2d_scratch/joint/ipsc +- name: fnet2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/fnet2d/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/fnet2d/joint/ipsc +- name: pix2pix2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/pix2pix2d_unetvit/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/nucleus/pix2pix2d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_joint__lite/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_joint__lite/eval_grouped.yaml new file mode 100644 index 000000000..0c397a688 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_joint__lite/eval_grouped.yaml @@ -0,0 +1,62 @@ +# @package _global_ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_joint/eval_grouped.yaml. Do not edit; regenerate. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino +compute_microssim: false +feature_metrics: + compute_fid: false + compute_prc: false + compute_mind: false +conditions: +- name: celldiff_r2__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/celldiff_r2/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/joint/a549__denv +- name: celldiff_r2__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/celldiff_r2/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/joint/a549__mock +- name: celldiff_r2__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv-lite + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache_pred/nucleus/celldiff_r2/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/joint/a549__zikv +- name: celldiff_r2__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc-lite + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache_pred/nucleus/celldiff_r2/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_phase_floor__2d_focus2d/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_phase_floor__2d_focus2d/eval_grouped.yaml new file mode 100644 index 000000000..adc48890c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/grouped/nucleus_phase_floor__2d_focus2d/eval_grouped.yaml @@ -0,0 +1,67 @@ +# @package _global_ +# 2D benchmark (focus2d.halfwidth=1): every metric on one GT-anchored focus plane per +# FOV/timepoint -- pixel metrics, MicroMS3IM and CP on the plane, deep features and per-cell +# similarity on its 3-plane slab, instance masks (cpdino) on the slab MIP. The 3D benchmark +# keeps the full volume in the canonical dirs; this bucket never writes there (save_dir re- +# rooted under /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/). Phase +# floor: the raw Phase3D input scored as the prediction (io.pred_is_source) on the same +# planes. Plane anchor: nucleus_area on the GT nucleus target (iPSC and A549). Caches: +# /focus2d_h1/ (GT and pred); CP reference __focus2d_h1. Generated by +# applications/dynacell/experiments/2026-10-07_2d-vs-3d-cost/make_focus2d_buckets.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino +focus2d: + halfwidth: 1 +conditions: +- name: phase__no_model__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/a549/evaluations_with_embeddings/eval_phase_nucleus_denv +- name: phase__no_model__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/a549/evaluations_with_embeddings/eval_phase_nucleus_mock +- name: phase__no_model__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/a549/evaluations_with_embeddings/eval_phase_nucleus_zikv +- name: phase__no_model__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_is_source: true + pred_cache_dir: null + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/eval_focus2d_h1/ipsc/evaluations_with_embeddings/eval_phase_nucleus diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/instance_ap/membrane_a549/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/instance_ap/membrane_a549/eval_grouped.yaml index 81a228a43..aa38e7a2e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/instance_ap/membrane_a549/eval_grouped.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/instance_ap/membrane_a549/eval_grouped.yaml @@ -1,13 +1,12 @@ # @package _global_ -# Grouped instance-AP leaf: membrane × a549 test (39 conditions, slice_fraction=0.3). Auto-generated by tools/generate_instance_ap_eval_configs.py. +# Grouped instance-AP leaf: membrane × a549 test (57 conditions; 2D plane = the GT focus plane, segmentation.slice_selection=focus from eval.yaml). Auto-generated by tools/generate_instance_ap_eval_configs.py. target_name: membrane compute_instance_ap: true compute_feature_metrics: false compute_microssim: false use_gpu: true segmentation: - backend: cellpose_watershed - slice_fraction: 0.3 + backend: cpdino nuclei_channel_name: Nuclei io: require_complete_cache: false @@ -24,426 +23,624 @@ conditions: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/a549_trained/celldiff_r2/denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/celldiff_r2/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_celldiff_r2_a549trained_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/a549__denv/instance_ap - name: celldiff_r2__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/a549_trained/celldiff_r2/mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/celldiff_r2/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_celldiff_r2_a549trained_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/a549__mock/instance_ap - name: celldiff_r2__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/a549_trained/celldiff_r2/zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/celldiff_r2/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_celldiff_r2_a549trained_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/a549__zikv/instance_ap - name: celldiff_r2__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_celldiff_r2_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/joint/celldiff_r2/denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/celldiff_r2/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_celldiff_r2_jointtrained_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/a549__denv/instance_ap - name: celldiff_r2__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_celldiff_r2_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/joint/celldiff_r2/mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/celldiff_r2/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_celldiff_r2_jointtrained_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/a549__mock/instance_ap - name: celldiff_r2__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_celldiff_r2_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/joint/celldiff_r2/zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/celldiff_r2/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_celldiff_r2_jointtrained_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/a549__zikv/instance_ap - name: celldiff_r2_iterative__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_iterative_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/ipsc_trained/celldiff_r2_iterative/denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/celldiff_r2_iterative/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_celldiff_r2_iterative_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/a549__denv/instance_ap - name: celldiff_r2_iterative__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_iterative_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/ipsc_trained/celldiff_r2_iterative/mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/celldiff_r2_iterative/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_celldiff_r2_iterative_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/a549__mock/instance_ap - name: celldiff_r2_iterative__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_iterative_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/ipsc_trained/celldiff_r2_iterative/zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/celldiff_r2_iterative/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_celldiff_r2_iterative_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/a549__zikv/instance_ap +- name: fnet2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fnet2d/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__denv/instance_ap +- name: fnet2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fnet2d/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__mock/instance_ap +- name: fnet2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fnet2d/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__zikv/instance_ap +- name: fnet2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fnet2d/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__denv/instance_ap +- name: fnet2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fnet2d/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__mock/instance_ap +- name: fnet2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fnet2d/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__zikv/instance_ap +- name: fnet2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fnet2d/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__denv/instance_ap +- name: fnet2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fnet2d/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__mock/instance_ap +- name: fnet2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fnet2d/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__zikv/instance_ap - name: fnet3d__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/a549_trained/fnet3d_paper/denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fnet3d_paper/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_fnet3d_a549trained_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/a549__denv/instance_ap - name: fnet3d__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/a549_trained/fnet3d_paper/mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fnet3d_paper/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_fnet3d_a549trained_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/a549__mock/instance_ap - name: fnet3d__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/a549_trained/fnet3d_paper/zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fnet3d_paper/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_fnet3d_a549trained_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/a549__zikv/instance_ap - name: fnet3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/ipsc_trained/fnet3d_paper/denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fnet3d_paper/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_fnet3d_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/a549__denv/instance_ap - name: fnet3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/ipsc_trained/fnet3d_paper/mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fnet3d_paper/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_fnet3d_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/a549__mock/instance_ap - name: fnet3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/ipsc_trained/fnet3d_paper/zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fnet3d_paper/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_fnet3d_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/a549__zikv/instance_ap - name: fnet3d__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fnet3d_paper_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/joint/fnet3d_paper/denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fnet3d_paper/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_fnet3d_jointtrained_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/a549__denv/instance_ap - name: fnet3d__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fnet3d_paper_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/joint/fnet3d_paper/mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fnet3d_paper/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_fnet3d_jointtrained_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/a549__mock/instance_ap - name: fnet3d__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fnet3d_paper_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/joint/fnet3d_paper/zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fnet3d_paper/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/a549__zikv/instance_ap +- name: pix2pix3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/pix2pix3d_unetvit/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__denv/instance_ap +- name: pix2pix3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/pix2pix3d_unetvit/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__mock/instance_ap +- name: pix2pix3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/pix2pix3d_unetvit/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__zikv/instance_ap +- name: pix2pix3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/pix2pix3d_unetvit/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__denv/instance_ap +- name: pix2pix3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/pix2pix3d_unetvit/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__mock/instance_ap +- name: pix2pix3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/pix2pix3d_unetvit/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__zikv/instance_ap +- name: pix2pix3d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/pix2pix3d_unetvit/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__denv/instance_ap +- name: pix2pix3d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/pix2pix3d_unetvit/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__mock/instance_ap +- name: pix2pix3d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/pix2pix3d_unetvit/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_fnet3d_jointtrained_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__zikv/instance_ap - name: unetvit3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_unetvit3d_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/ipsc_trained/unetvit3d/denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/unetvit3d/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unetvit3d_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/a549__denv/instance_ap - name: unetvit3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_unetvit3d_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/ipsc_trained/unetvit3d/mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/unetvit3d/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unetvit3d_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/a549__mock/instance_ap - name: unetvit3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_unetvit3d_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/ipsc_trained/unetvit3d/zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/unetvit3d/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unetvit3d_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/a549__zikv/instance_ap - name: unext2__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/a549_trained/fcmae_vscyto3d_scratch/denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_scratch/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unext2_a549trained_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/a549__denv/instance_ap - name: unext2__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/a549_trained/fcmae_vscyto3d_scratch/mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_scratch/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unext2_a549trained_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/a549__mock/instance_ap - name: unext2__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/a549_trained/fcmae_vscyto3d_scratch/zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_scratch/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unext2_a549trained_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/a549__zikv/instance_ap - name: unext2__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/ipsc_trained/fcmae_vscyto3d_scratch/denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_scratch/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unext2_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/a549__denv/instance_ap - name: unext2__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/ipsc_trained/fcmae_vscyto3d_scratch/mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_scratch/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unext2_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/a549__mock/instance_ap - name: unext2__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/ipsc_trained/fcmae_vscyto3d_scratch/zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_scratch/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unext2_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/a549__zikv/instance_ap - name: unext2__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fcmae_vscyto3d_scratch_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/joint/fcmae_vscyto3d_scratch/denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_scratch/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unext2_jointtrained_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/a549__denv/instance_ap - name: unext2__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fcmae_vscyto3d_scratch_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/joint/fcmae_vscyto3d_scratch/mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_scratch/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unext2_jointtrained_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/a549__mock/instance_ap - name: unext2__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fcmae_vscyto3d_scratch_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/joint/fcmae_vscyto3d_scratch/zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_scratch/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unext2_jointtrained_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/a549__zikv/instance_ap - name: vscyto3d__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/a549_trained/fcmae_vscyto3d_pretrained/denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_pretrained/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_vscyto3d_a549trained_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/a549__denv/instance_ap - name: vscyto3d__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/a549_trained/fcmae_vscyto3d_pretrained/mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_pretrained/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_vscyto3d_a549trained_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/a549__mock/instance_ap - name: vscyto3d__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/a549_trained/fcmae_vscyto3d_pretrained/zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_pretrained/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_vscyto3d_a549trained_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/a549__zikv/instance_ap - name: vscyto3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/ipsc_trained/fcmae_vscyto3d_pretrained/denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_vscyto3d_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__denv/instance_ap - name: vscyto3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/ipsc_trained/fcmae_vscyto3d_pretrained/mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_vscyto3d_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__mock/instance_ap - name: vscyto3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/ipsc_trained/fcmae_vscyto3d_pretrained/zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_vscyto3d_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/instance_ap - name: vscyto3d__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-caax-denv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fcmae_vscyto3d_pretrained_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/joint/fcmae_vscyto3d_pretrained/denv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_pretrained/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_vscyto3d_jointtrained_membrane_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/a549__denv/instance_ap - name: vscyto3d__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-caax-mock target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fcmae_vscyto3d_pretrained_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/joint/fcmae_vscyto3d_pretrained/mock - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_pretrained/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_vscyto3d_jointtrained_membrane_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/a549__mock/instance_ap - name: vscyto3d__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-caax-zikv target: caax io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_fcmae_vscyto3d_pretrained_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/joint/fcmae_vscyto3d_pretrained/zikv - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_pretrained/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_vscyto3d_jointtrained_membrane_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/a549__zikv/instance_ap diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/instance_ap/membrane_ipsc/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/instance_ap/membrane_ipsc/eval_grouped.yaml index 9442bf98d..85209c820 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/instance_ap/membrane_ipsc/eval_grouped.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/instance_ap/membrane_ipsc/eval_grouped.yaml @@ -1,13 +1,12 @@ # @package _global_ -# Grouped instance-AP leaf: membrane × ipsc test (15 conditions, slice_fraction=0.5). Auto-generated by tools/generate_instance_ap_eval_configs.py. +# Grouped instance-AP leaf: membrane × ipsc test (21 conditions; 2D plane = the GT focus plane, segmentation.slice_selection=focus from eval.yaml). Auto-generated by tools/generate_instance_ap_eval_configs.py. target_name: membrane compute_instance_ap: true compute_feature_metrics: false compute_microssim: false use_gpu: true segmentation: - backend: cellpose_watershed - slice_fraction: 0.5 + backend: cpdino nuclei_channel_name: Nuclei io: require_complete_cache: false @@ -24,147 +23,207 @@ conditions: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_celldiff_r2_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/a549_trained/celldiff_r2/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/celldiff_r2/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_celldiff_r2_a549trained_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/ipsc/instance_ap - name: celldiff_r2__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/memb_celldiff_r2.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/joint/celldiff_r2/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/celldiff_r2/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_celldiff_r2_jointtrained_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/ipsc/instance_ap - name: celldiff_r2_denoise__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_celldiff_r2_denoise.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/ipsc_trained/celldiff_r2_denoise/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_denoise/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/celldiff_r2_denoise/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_celldiff_r2_denoise_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_denoise/ipsc/ipsc/instance_ap - name: celldiff_r2_iterative__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_celldiff_r2_iterative.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/ipsc_trained/celldiff_r2_iterative/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/celldiff_r2_iterative/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_celldiff_r2_iterative_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/ipsc/instance_ap - name: celldiff_r2_sliding_window__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_celldiff_r2_sliding_window.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/ipsc_trained/celldiff_r2_sliding_window/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_sliding_window/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/celldiff_r2_sliding_window/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_celldiff_r2_sliding_window_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_sliding_window/ipsc/ipsc/instance_ap +- name: fnet2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/fnet2d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/ipsc/instance_ap +- name: fnet2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/fnet2d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/ipsc/instance_ap +- name: fnet2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/fnet2d/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/ipsc/instance_ap - name: fnet3d__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fnet3d_paper_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/a549_trained/fnet3d_paper/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/fnet3d_paper/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_fnet3d_a549trained_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/ipsc/instance_ap - name: fnet3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fnet3d_paper.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/ipsc_trained/fnet3d_paper/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/fnet3d_paper/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_fnet3d_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/ipsc/instance_ap - name: fnet3d__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/memb_fnet3d_paper_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/joint/fnet3d_paper/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/fnet3d_paper/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/ipsc/instance_ap +- name: pix2pix3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/pix2pix3d_unetvit/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/ipsc/instance_ap +- name: pix2pix3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/pix2pix3d_unetvit/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/ipsc/instance_ap +- name: pix2pix3d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/pix2pix3d_unetvit/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_fnet3d_jointtrained_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/ipsc/instance_ap - name: unetvit3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_unetvit3d.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/ipsc_trained/unetvit3d/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/unetvit3d/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_unetvit3d_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/ipsc/instance_ap - name: unext2__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fcmae_vscyto3d_scratch_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/a549_trained/fcmae_vscyto3d_scratch/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_scratch/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_unext2_a549trained_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/ipsc/instance_ap - name: unext2__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fcmae_vscyto3d_scratch.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/ipsc_trained/fcmae_vscyto3d_scratch/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_scratch/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_unext2_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/ipsc/instance_ap - name: unext2__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/memb_fcmae_vscyto3d_scratch_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/joint/fcmae_vscyto3d_scratch/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_scratch/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_unext2_jointtrained_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/ipsc/instance_ap - name: vscyto3d__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fcmae_vscyto3d_pretrained_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/a549_trained/fcmae_vscyto3d_pretrained/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_pretrained/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_vscyto3d_a549trained_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/ipsc/instance_ap - name: vscyto3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fcmae_vscyto3d_pretrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/ipsc_trained/fcmae_vscyto3d_pretrained/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_pretrained/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_vscyto3d_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/ipsc/instance_ap - name: vscyto3d__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: membrane io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/memb_fcmae_vscyto3d_pretrained_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/joint/fcmae_vscyto3d_pretrained/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/membrane/fcmae_vscyto3d_pretrained/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_vscyto3d_jointtrained_membrane + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/ipsc/instance_ap diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/instance_ap/nucleus_a549/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/instance_ap/nucleus_a549/eval_grouped.yaml index 69c7184cc..737049d45 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/instance_ap/nucleus_a549/eval_grouped.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/instance_ap/nucleus_a549/eval_grouped.yaml @@ -1,13 +1,12 @@ # @package _global_ -# Grouped instance-AP leaf: nucleus × a549 test (45 conditions, slice_fraction=0.3). Auto-generated by tools/generate_instance_ap_eval_configs.py. +# Grouped instance-AP leaf: nucleus × a549 test (63 conditions; 2D plane = the GT focus plane, segmentation.slice_selection=focus from eval.yaml). Auto-generated by tools/generate_instance_ap_eval_configs.py. target_name: nucleus compute_instance_ap: true compute_feature_metrics: false compute_microssim: false use_gpu: true segmentation: - backend: cellpose - slice_fraction: 0.3 + backend: cpdino io: require_complete_cache: false runtime: @@ -23,447 +22,627 @@ conditions: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_r2_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/a549_trained/celldiff_r2/denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/celldiff_r2/a549/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_celldiff_r2_a549trained_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/a549__denv/instance_ap - name: celldiff_r2__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_r2_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/a549_trained/celldiff_r2/mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/celldiff_r2/a549/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_celldiff_r2_a549trained_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/a549__mock/instance_ap - name: celldiff_r2__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_r2_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/a549_trained/celldiff_r2/zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/celldiff_r2/a549/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_celldiff_r2_a549trained_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/a549__zikv/instance_ap - name: celldiff_r2__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_celldiff_r2_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/joint/celldiff_r2/denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/celldiff_r2/joint/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_celldiff_r2_jointtrained_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/a549__denv/instance_ap - name: celldiff_r2__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_celldiff_r2_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/joint/celldiff_r2/mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/celldiff_r2/joint/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_celldiff_r2_jointtrained_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/a549__mock/instance_ap - name: celldiff_r2__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_celldiff_r2_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/joint/celldiff_r2/zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/celldiff_r2/joint/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_celldiff_r2_jointtrained_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/a549__zikv/instance_ap - name: celldiff_r2_iterative__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_r2_iterative_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/ipsc_trained/celldiff_r2_iterative/denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/celldiff_r2_iterative/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_celldiff_r2_iterative_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/a549__denv/instance_ap - name: celldiff_r2_iterative__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_r2_iterative_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/ipsc_trained/celldiff_r2_iterative/mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/celldiff_r2_iterative/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_celldiff_r2_iterative_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/a549__mock/instance_ap - name: celldiff_r2_iterative__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_r2_iterative_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/ipsc_trained/celldiff_r2_iterative/zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/celldiff_r2_iterative/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_celldiff_r2_iterative_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/a549__zikv/instance_ap +- name: fnet2d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet2d/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__denv/instance_ap +- name: fnet2d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet2d/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__mock/instance_ap +- name: fnet2d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet2d/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__zikv/instance_ap +- name: fnet2d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet2d/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__denv/instance_ap +- name: fnet2d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet2d/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__mock/instance_ap +- name: fnet2d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet2d/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__zikv/instance_ap +- name: fnet2d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet2d/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__denv/instance_ap +- name: fnet2d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet2d/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__mock/instance_ap +- name: fnet2d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet2d/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__zikv/instance_ap - name: fnet3d__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/a549_trained/fnet3d_paper/denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet3d_paper/a549/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_fnet3d_a549trained_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/a549__denv/instance_ap - name: fnet3d__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/a549_trained/fnet3d_paper/mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet3d_paper/a549/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_fnet3d_a549trained_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/a549__mock/instance_ap - name: fnet3d__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/a549_trained/fnet3d_paper/zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet3d_paper/a549/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_fnet3d_a549trained_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/a549__zikv/instance_ap - name: fnet3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/ipsc_trained/fnet3d_paper/denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet3d_paper/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_fnet3d_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/a549__denv/instance_ap - name: fnet3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/ipsc_trained/fnet3d_paper/mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet3d_paper/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_fnet3d_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/a549__mock/instance_ap - name: fnet3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/ipsc_trained/fnet3d_paper/zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet3d_paper/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_fnet3d_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/a549__zikv/instance_ap - name: fnet3d__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_fnet3d_paper_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/joint/fnet3d_paper/denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet3d_paper/joint/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_fnet3d_jointtrained_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/a549__denv/instance_ap - name: fnet3d__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_fnet3d_paper_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/joint/fnet3d_paper/mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet3d_paper/joint/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_fnet3d_jointtrained_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/a549__mock/instance_ap - name: fnet3d__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_fnet3d_paper_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/joint/fnet3d_paper/zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet3d_paper/joint/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_fnet3d_jointtrained_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/a549__zikv/instance_ap +- name: fnet3d_bigpatch__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet3d_bigpatch/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/a549__denv/instance_ap +- name: fnet3d_bigpatch__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet3d_bigpatch/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/a549__mock/instance_ap +- name: fnet3d_bigpatch__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet3d_bigpatch/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/a549__zikv/instance_ap +- name: fnet3d_vscyto3daug__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet3d_vscyto3daug/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/a549__denv/instance_ap +- name: fnet3d_vscyto3daug__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet3d_vscyto3daug/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/a549__mock/instance_ap +- name: fnet3d_vscyto3daug__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fnet3d_vscyto3daug/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/a549__zikv/instance_ap - name: pix2pix3d__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit_a549trained__h2b_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/a549_trained/pix2pix3d_unetvit/denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/pix2pix3d_unetvit/a549/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_pix2pix3d_a549trained_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__denv/instance_ap - name: pix2pix3d__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit_a549trained__h2b_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/a549_trained/pix2pix3d_unetvit/mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/pix2pix3d_unetvit/a549/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_pix2pix3d_a549trained_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__mock/instance_ap - name: pix2pix3d__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit_a549trained__h2b_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/a549_trained/pix2pix3d_unetvit/zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/pix2pix3d_unetvit/a549/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_pix2pix3d_a549trained_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__zikv/instance_ap - name: pix2pix3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit__h2b_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/ipsc_trained/pix2pix3d_unetvit/denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/pix2pix3d_unetvit/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_pix2pix3d_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__denv/instance_ap - name: pix2pix3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit__h2b_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/ipsc_trained/pix2pix3d_unetvit/mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/pix2pix3d_unetvit/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_pix2pix3d_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__mock/instance_ap - name: pix2pix3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit__h2b_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/ipsc_trained/pix2pix3d_unetvit/zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/pix2pix3d_unetvit/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_pix2pix3d_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__zikv/instance_ap - name: pix2pix3d__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_pix2pix3d_unetvit__h2b_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/joint/pix2pix3d_unetvit/denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/pix2pix3d_unetvit/joint/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_pix2pix3d_jointtrained_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__denv/instance_ap - name: pix2pix3d__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_pix2pix3d_unetvit__h2b_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/joint/pix2pix3d_unetvit/mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/pix2pix3d_unetvit/joint/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_pix2pix3d_jointtrained_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__mock/instance_ap - name: pix2pix3d__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_pix2pix3d_unetvit__h2b_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/joint/pix2pix3d_unetvit/zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/pix2pix3d_unetvit/joint/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_pix2pix3d_jointtrained_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__zikv/instance_ap - name: unetvit3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucleus_unetvit3d_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/ipsc_trained/unetvit3d/denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/unetvit3d/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unetvit3d_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/a549__denv/instance_ap - name: unetvit3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucleus_unetvit3d_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/ipsc_trained/unetvit3d/mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/unetvit3d/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unetvit3d_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/a549__mock/instance_ap - name: unetvit3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucleus_unetvit3d_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/ipsc_trained/unetvit3d/zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/unetvit3d/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unetvit3d_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/a549__zikv/instance_ap - name: unext2__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/a549_trained/fcmae_vscyto3d_scratch/denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_scratch/a549/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unext2_a549trained_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/a549__denv/instance_ap - name: unext2__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/a549_trained/fcmae_vscyto3d_scratch/mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_scratch/a549/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unext2_a549trained_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/a549__mock/instance_ap - name: unext2__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/a549_trained/fcmae_vscyto3d_scratch/zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_scratch/a549/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unext2_a549trained_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/a549__zikv/instance_ap - name: unext2__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/ipsc_trained/fcmae_vscyto3d_scratch/denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unext2_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__denv/instance_ap - name: unext2__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/ipsc_trained/fcmae_vscyto3d_scratch/mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unext2_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__mock/instance_ap - name: unext2__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/ipsc_trained/fcmae_vscyto3d_scratch/zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unext2_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__zikv/instance_ap - name: unext2__joint__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_fcmae_vscyto3d_scratch_jointtrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/joint/fcmae_vscyto3d_scratch/denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_scratch/joint/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unext2_jointtrained_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/a549__denv/instance_ap - name: unext2__joint__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_fcmae_vscyto3d_scratch_jointtrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/joint/fcmae_vscyto3d_scratch/mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_scratch/joint/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unext2_jointtrained_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/a549__mock/instance_ap - name: unext2__joint__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_fcmae_vscyto3d_scratch_jointtrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/joint/fcmae_vscyto3d_scratch/zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_scratch/joint/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_unext2_jointtrained_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/a549__zikv/instance_ap - name: vscyto3d__a549_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_a549trained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/a549_trained/fcmae_vscyto3d_pretrained/denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_pretrained/a549/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_vscyto3d_a549trained_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/a549__denv/instance_ap - name: vscyto3d__a549_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_a549trained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/a549_trained/fcmae_vscyto3d_pretrained/mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_pretrained/a549/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_vscyto3d_a549trained_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/a549__mock/instance_ap - name: vscyto3d__a549_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_a549trained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/a549_trained/fcmae_vscyto3d_pretrained/zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_pretrained/a549/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_vscyto3d_a549trained_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/a549__zikv/instance_ap - name: vscyto3d__ipsc_trained__a549_denv benchmark: dataset_ref: dataset: a549-mantis-h2b-denv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_denv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/ipsc_trained/fcmae_vscyto3d_pretrained/denv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__denv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_vscyto3d_nucleus_denv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__denv/instance_ap - name: vscyto3d__ipsc_trained__a549_mock benchmark: dataset_ref: dataset: a549-mantis-h2b-mock target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_mock.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/ipsc_trained/fcmae_vscyto3d_pretrained/mock + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__mock save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_vscyto3d_nucleus_mock + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__mock/instance_ap - name: vscyto3d__ipsc_trained__a549_zikv benchmark: dataset_ref: dataset: a549-mantis-h2b-zikv target: h2b io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_zikv.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/ipsc_trained/fcmae_vscyto3d_pretrained/zikv + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/instance_ap +- name: vscyto3d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_pretrained/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/a549__denv/instance_ap +- name: vscyto3d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_pretrained/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/a549__mock/instance_ap +- name: vscyto3d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_pretrained/joint/a549__zikv save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_instance_ap/eval_vscyto3d_nucleus_zikv + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/a549__zikv/instance_ap diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/instance_ap/nucleus_ipsc/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/instance_ap/nucleus_ipsc/eval_grouped.yaml index 4ca04b101..16086f110 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/instance_ap/nucleus_ipsc/eval_grouped.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/instance_ap/nucleus_ipsc/eval_grouped.yaml @@ -1,13 +1,12 @@ # @package _global_ -# Grouped instance-AP leaf: nucleus × ipsc test (17 conditions, slice_fraction=0.5). Auto-generated by tools/generate_instance_ap_eval_configs.py. +# Grouped instance-AP leaf: nucleus × ipsc test (23 conditions; 2D plane = the GT focus plane, segmentation.slice_selection=focus from eval.yaml). Auto-generated by tools/generate_instance_ap_eval_configs.py. target_name: nucleus compute_instance_ap: true compute_feature_metrics: false compute_microssim: false use_gpu: true segmentation: - backend: cellpose - slice_fraction: 0.5 + backend: cpdino io: require_complete_cache: false runtime: @@ -23,167 +22,227 @@ conditions: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_celldiff_r2_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/a549_trained/celldiff_r2/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/celldiff_r2/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_celldiff_r2_a549trained_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/ipsc/instance_ap - name: celldiff_r2__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/nucl_celldiff_r2.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/joint/celldiff_r2/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/celldiff_r2/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_celldiff_r2_jointtrained_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/ipsc/instance_ap - name: celldiff_r2_denoise__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_celldiff_r2_denoise.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/ipsc_trained/celldiff_r2_denoise/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_denoise/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/celldiff_r2_denoise/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_celldiff_r2_denoise_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_denoise/ipsc/ipsc/instance_ap - name: celldiff_r2_iterative__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_celldiff_r2_iterative.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/ipsc_trained/celldiff_r2_iterative/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/celldiff_r2_iterative/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_celldiff_r2_iterative_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/ipsc/instance_ap - name: celldiff_r2_sliding_window__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_celldiff_r2_sliding_window.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/ipsc_trained/celldiff_r2_sliding_window/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_sliding_window/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/celldiff_r2_sliding_window/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_celldiff_r2_sliding_window_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_sliding_window/ipsc/ipsc/instance_ap +- name: fnet2d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/fnet2d/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/ipsc/instance_ap +- name: fnet2d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/fnet2d/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/ipsc/instance_ap +- name: fnet2d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/fnet2d/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/ipsc/instance_ap - name: fnet3d__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fnet3d_paper_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/a549_trained/fnet3d_paper/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/fnet3d_paper/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_fnet3d_a549trained_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/ipsc/instance_ap - name: fnet3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fnet3d_paper.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/ipsc_trained/fnet3d_paper/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/fnet3d_paper/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_fnet3d_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/ipsc/instance_ap - name: fnet3d__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/nucl_fnet3d_paper_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/joint/fnet3d_paper/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/fnet3d_paper/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_fnet3d_jointtrained_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/ipsc/instance_ap +- name: fnet3d_bigpatch__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/fnet3d_bigpatch/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/ipsc/instance_ap +- name: fnet3d_vscyto3daug__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/fnet3d_vscyto3daug/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/ipsc/instance_ap - name: pix2pix3d__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_pix2pix3d_unetvit_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/a549_trained/pix2pix3d_unetvit/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/pix2pix3d_unetvit/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_pix2pix3d_a549trained_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/ipsc/instance_ap - name: pix2pix3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_pix2pix3d_unetvit.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/ipsc_trained/pix2pix3d_unetvit/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/pix2pix3d_unetvit/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_pix2pix3d_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/ipsc/instance_ap - name: pix2pix3d__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/nucl_pix2pix3d_unetvit.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/joint/pix2pix3d_unetvit/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/pix2pix3d_unetvit/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_pix2pix3d_jointtrained_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/ipsc/instance_ap - name: unetvit3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_unetvit3d.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/ipsc_trained/unetvit3d/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/unetvit3d/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_unetvit3d_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/ipsc/instance_ap - name: unext2__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fcmae_vscyto3d_scratch_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/a549_trained/fcmae_vscyto3d_scratch/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_scratch/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_unext2_a549trained_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/ipsc/instance_ap - name: unext2__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fcmae_vscyto3d_scratch.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/ipsc_trained/fcmae_vscyto3d_scratch/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_scratch/ipsc/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_unext2_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/ipsc/instance_ap - name: unext2__joint__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/nucl_fcmae_vscyto3d_scratch_jointtrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/joint/fcmae_vscyto3d_scratch/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_scratch/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_unext2_jointtrained_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/ipsc/instance_ap - name: vscyto3d__a549_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fcmae_vscyto3d_pretrained_a549trained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/a549_trained/fcmae_vscyto3d_pretrained/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_pretrained/a549/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_vscyto3d_a549trained_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/ipsc/instance_ap - name: vscyto3d__ipsc_trained__ipsc benchmark: dataset_ref: dataset: aics-hipsc target: nucleus io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fcmae_vscyto3d_pretrained.zarr - pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/ipsc_trained/fcmae_vscyto3d_pretrained/ipsc + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_pretrained/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/ipsc/instance_ap +- name: vscyto3d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred_instance_ap/nucleus/fcmae_vscyto3d_pretrained/joint/ipsc save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_instance_ap/eval_vscyto3d_nucleus + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/ipsc/instance_ap diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index f5fd532e1..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../membrane/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index 2353e2df1..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../membrane/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index bee63297a..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../membrane/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 120000 index 8ac201261..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../membrane/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index ec7df7fac..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index 4a18b3957..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index 55ad06bc1..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_cytoland/cytoland/eval__a549_mantis.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_cytoland/cytoland/eval__a549_mantis.yaml index 69789fffa..4b8a15ec9 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_cytoland/cytoland/eval__a549_mantis.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_cytoland/cytoland/eval__a549_mantis.yaml @@ -14,10 +14,8 @@ benchmark: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose_watershed + backend: cpdino nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: false conditions: - name: a549_mock @@ -26,7 +24,7 @@ conditions: dataset: a549-mantis-caax-mock io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/dual_nucl_memb_fcmae_vscyto3d_pretrained_cytoland_mock.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_cytoland_membrane_mock - name: a549_denv @@ -35,7 +33,7 @@ conditions: dataset: a549-mantis-caax-denv io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/dual_nucl_memb_fcmae_vscyto3d_pretrained_cytoland_denv.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_cytoland_membrane_denv - name: a549_zikv @@ -44,6 +42,6 @@ conditions: dataset: a549-mantis-caax-zikv io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/dual_nucl_memb_fcmae_vscyto3d_pretrained_cytoland_zikv.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_cytoland_membrane_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_cytoland/cytoland/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_cytoland/cytoland/eval__ipsc_confocal.yaml index ca78d87d4..aac08ad77 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_cytoland/cytoland/eval__ipsc_confocal.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_cytoland/cytoland/eval__ipsc_confocal.yaml @@ -12,10 +12,8 @@ io: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose_watershed + backend: cpdino nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: false save: save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_vscyto3d_cytoland_membrane diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_infectionft/infectionft/eval__a549_mantis.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_infectionft/infectionft/eval__a549_mantis.yaml index dedeb23aa..84998e091 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_infectionft/infectionft/eval__a549_mantis.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_infectionft/infectionft/eval__a549_mantis.yaml @@ -14,10 +14,8 @@ benchmark: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose_watershed + backend: cpdino nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: false conditions: - name: a549_mock @@ -26,7 +24,7 @@ conditions: dataset: a549-mantis-caax-mock io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/dual_nucl_memb_fcmae_vscyto3d_pretrained_infectionft_mock.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_infectionft_membrane_mock - name: a549_denv @@ -35,7 +33,7 @@ conditions: dataset: a549-mantis-caax-denv io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/dual_nucl_memb_fcmae_vscyto3d_pretrained_infectionft_denv.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_infectionft_membrane_denv - name: a549_zikv @@ -44,6 +42,6 @@ conditions: dataset: a549-mantis-caax-zikv io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/dual_nucl_memb_fcmae_vscyto3d_pretrained_infectionft_zikv.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_infectionft_membrane_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_infectionft/infectionft/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_infectionft/infectionft/eval__ipsc_confocal.yaml index 45d439ac0..9bff26fba 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_infectionft/infectionft/eval__ipsc_confocal.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_infectionft/infectionft/eval__ipsc_confocal.yaml @@ -12,10 +12,8 @@ io: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose_watershed + backend: cpdino nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: false save: save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_vscyto3d_infectionft_membrane diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_randinit/randinit/eval__a549_mantis.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_randinit/randinit/eval__a549_mantis.yaml index cc1ee7a60..a9d1cc127 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_randinit/randinit/eval__a549_mantis.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_randinit/randinit/eval__a549_mantis.yaml @@ -15,10 +15,8 @@ benchmark: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose_watershed + backend: cpdino nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: false conditions: - name: a549_mock @@ -27,7 +25,7 @@ conditions: dataset: a549-mantis-caax-mock io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_randinit_mock.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_randinit_membrane_mock - name: a549_denv @@ -36,7 +34,7 @@ conditions: dataset: a549-mantis-caax-denv io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_randinit_denv.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_randinit_membrane_denv - name: a549_zikv @@ -45,6 +43,6 @@ conditions: dataset: a549-mantis-caax-zikv io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_randinit_zikv.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_vscyto3d_randinit_membrane_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_randinit/randinit/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_randinit/randinit/eval__ipsc_confocal.yaml index 98900a662..b5af71f7b 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_randinit/randinit/eval__ipsc_confocal.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_pretrained_randinit/randinit/eval__ipsc_confocal.yaml @@ -12,10 +12,8 @@ io: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose_watershed + backend: cpdino nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: false save: save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_vscyto3d_randinit_membrane diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index d825510f9..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index d66c60b89..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index b23a90c58..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index 12895ce10..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index 495ec10aa..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index a05677367..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/phase/eval__a549_mantis_caax_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/phase/eval__a549_mantis_caax_denv.yaml new file mode 100644 index 000000000..a6714c22c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/phase/eval__a549_mantis_caax_denv.yaml @@ -0,0 +1,25 @@ +# @package _global_ +# Phase baseline (no model): raw Phase3D input scored as the "prediction" against +# the A549 denv membrane (CAAX) GT. cpdino segments the phase whole cell and +# carves the GT nucleus; the carve seeds come from the separate H2B store. Phase3D +# lives in the CAAX store, so io.pred_path defaults there (positions match GT). +defaults: + - override /target: membrane + - override /predict_set: a549_mantis_caax_denv + +benchmark: + dataset_ref: + target: caax + +io: + pred_is_source: true + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + +compute_feature_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei + +save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_phase_membrane_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/phase/eval__a549_mantis_caax_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/phase/eval__a549_mantis_caax_mock.yaml new file mode 100644 index 000000000..e34ba7f98 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/phase/eval__a549_mantis_caax_mock.yaml @@ -0,0 +1,25 @@ +# @package _global_ +# Phase baseline (no model): raw Phase3D input scored as the "prediction" against +# the A549 mock membrane (CAAX) GT. cpdino segments the phase whole cell and +# carves the GT nucleus; the carve seeds come from the separate H2B store. Phase3D +# lives in the CAAX store, so io.pred_path defaults there (positions match GT). +defaults: + - override /target: membrane + - override /predict_set: a549_mantis_caax_mock + +benchmark: + dataset_ref: + target: caax + +io: + pred_is_source: true + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + +compute_feature_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei + +save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_phase_membrane_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/phase/eval__a549_mantis_caax_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/phase/eval__a549_mantis_caax_zikv.yaml new file mode 100644 index 000000000..4adb989a6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/phase/eval__a549_mantis_caax_zikv.yaml @@ -0,0 +1,25 @@ +# @package _global_ +# Phase baseline (no model): raw Phase3D input scored as the "prediction" against +# the A549 zikv membrane (CAAX) GT. cpdino segments the phase whole cell and +# carves the GT nucleus; the carve seeds come from the separate H2B store. Phase3D +# lives in the CAAX store, so io.pred_path defaults there (positions match GT). +defaults: + - override /target: membrane + - override /predict_set: a549_mantis_caax_zikv + +benchmark: + dataset_ref: + target: caax + +io: + pred_is_source: true + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + +compute_feature_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei + +save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_phase_membrane_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/phase/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/phase/eval__ipsc_confocal.yaml new file mode 100644 index 000000000..8c768bafc --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/phase/eval__ipsc_confocal.yaml @@ -0,0 +1,21 @@ +# @package _global_ +# Phase baseline (no model): the raw Phase3D input scored as the "prediction" +# against the iPSC membrane GT. cpdino segments the phase image into whole cells +# and carves the GT nucleus (subtract_nuclei default). iPSC nuclei live in the same +# cell.zarr, so no separate nuclei_gt_path. io.pred_is_source reads Phase3D and +# defaults io.pred_path to the GT store (cell.zarr). +defaults: + - override /target: membrane + - override /predict_set: ipsc_confocal + +io: + pred_is_source: true + +compute_feature_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei + +save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_phase_membrane diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index 69af3ff0d..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index 1c891950f..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index b5384f051..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 120000 index b6113f5d2..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../membrane/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_cytolandft/a549_mantis/eval__a549_mantis.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_cytolandft/a549_mantis/eval__a549_mantis.yaml index 65e0dd123..490d923b1 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_cytolandft/a549_mantis/eval__a549_mantis.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_cytolandft/a549_mantis/eval__a549_mantis.yaml @@ -14,10 +14,8 @@ benchmark: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose_watershed + backend: cpdino nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: false conditions: - name: a549_mock @@ -26,7 +24,7 @@ conditions: dataset: a549-mantis-caax-mock io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/dual_nucl_memb_vscyto3d_cytolandft_a549trained_mock.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_cytolandft_a549trained/eval_vscyto3d_cytolandft_a549trained_membrane_mock - name: a549_denv @@ -35,7 +33,7 @@ conditions: dataset: a549-mantis-caax-denv io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/dual_nucl_memb_vscyto3d_cytolandft_a549trained_denv.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_cytolandft_a549trained/eval_vscyto3d_cytolandft_a549trained_membrane_denv - name: a549_zikv @@ -44,6 +42,6 @@ conditions: dataset: a549-mantis-caax-zikv io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/dual_nucl_memb_vscyto3d_cytolandft_a549trained_zikv.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_cytolandft_a549trained/eval_vscyto3d_cytolandft_a549trained_membrane_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_cytolandft/a549_mantis/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_cytolandft/a549_mantis/eval__ipsc_confocal.yaml index cfab86e3b..6e1079ff1 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_cytolandft/a549_mantis/eval__ipsc_confocal.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_cytolandft/a549_mantis/eval__ipsc_confocal.yaml @@ -11,10 +11,8 @@ io: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose_watershed + backend: cpdino nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: false save: save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_cytolandft_a549trained/eval_vscyto3d_cytolandft_a549trained_membrane diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_cytolandft/ipsc_confocal/eval__a549_mantis.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_cytolandft/ipsc_confocal/eval__a549_mantis.yaml index 4b8c7e835..bbd52ed69 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_cytolandft/ipsc_confocal/eval__a549_mantis.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_cytolandft/ipsc_confocal/eval__a549_mantis.yaml @@ -14,10 +14,8 @@ benchmark: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose_watershed + backend: cpdino nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: false conditions: - name: a549_mock @@ -26,7 +24,7 @@ conditions: dataset: a549-mantis-caax-mock io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/dual_nucl_memb_vscyto3d_cytolandft_mock.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_cytolandft/eval_vscyto3d_cytolandft_membrane_mock - name: a549_denv @@ -35,7 +33,7 @@ conditions: dataset: a549-mantis-caax-denv io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/dual_nucl_memb_vscyto3d_cytolandft_denv.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_cytolandft/eval_vscyto3d_cytolandft_membrane_denv - name: a549_zikv @@ -44,6 +42,6 @@ conditions: dataset: a549-mantis-caax-zikv io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/dual_nucl_memb_vscyto3d_cytolandft_zikv.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_cytolandft/eval_vscyto3d_cytolandft_membrane_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_cytolandft/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_cytolandft/ipsc_confocal/eval__ipsc_confocal.yaml index fce7835f3..96eaca95e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_cytolandft/ipsc_confocal/eval__ipsc_confocal.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_cytolandft/ipsc_confocal/eval__ipsc_confocal.yaml @@ -11,10 +11,8 @@ io: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose_watershed + backend: cpdino nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: false save: save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_cytolandft/eval_vscyto3d_cytolandft_membrane diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_infectionft_dynacellft/a549_mantis/eval__a549_mantis.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_infectionft_dynacellft/a549_mantis/eval__a549_mantis.yaml index 9d875ac72..dc1a8954e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_infectionft_dynacellft/a549_mantis/eval__a549_mantis.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_infectionft_dynacellft/a549_mantis/eval__a549_mantis.yaml @@ -14,10 +14,8 @@ benchmark: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose_watershed + backend: cpdino nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: false conditions: - name: a549_mock @@ -26,7 +24,7 @@ conditions: dataset: a549-mantis-caax-mock io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/dual_nucl_memb_vscyto3d_infectionft_dynacellft_a549trained_mock.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_infectionft_dynacellft_a549trained/eval_vscyto3d_infectionft_dynacellft_a549trained_membrane_mock - name: a549_denv @@ -35,7 +33,7 @@ conditions: dataset: a549-mantis-caax-denv io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/dual_nucl_memb_vscyto3d_infectionft_dynacellft_a549trained_denv.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_infectionft_dynacellft_a549trained/eval_vscyto3d_infectionft_dynacellft_a549trained_membrane_denv - name: a549_zikv @@ -44,6 +42,6 @@ conditions: dataset: a549-mantis-caax-zikv io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/dual_nucl_memb_vscyto3d_infectionft_dynacellft_a549trained_zikv.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_infectionft_dynacellft_a549trained/eval_vscyto3d_infectionft_dynacellft_a549trained_membrane_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_infectionft_dynacellft/a549_mantis/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_infectionft_dynacellft/a549_mantis/eval__ipsc_confocal.yaml index 4bf0e5a7d..ba5098669 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_infectionft_dynacellft/a549_mantis/eval__ipsc_confocal.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_infectionft_dynacellft/a549_mantis/eval__ipsc_confocal.yaml @@ -11,10 +11,8 @@ io: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose_watershed + backend: cpdino nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: false save: save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_infectionft_dynacellft_a549trained/eval_vscyto3d_infectionft_dynacellft_a549trained_membrane diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_infectionft_dynacellft/ipsc_confocal/eval__a549_mantis.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_infectionft_dynacellft/ipsc_confocal/eval__a549_mantis.yaml index 3c6bd0808..bcc0d05c9 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_infectionft_dynacellft/ipsc_confocal/eval__a549_mantis.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_infectionft_dynacellft/ipsc_confocal/eval__a549_mantis.yaml @@ -14,10 +14,8 @@ benchmark: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose_watershed + backend: cpdino nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: false conditions: - name: a549_mock @@ -26,7 +24,7 @@ conditions: dataset: a549-mantis-caax-mock io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/dual_nucl_memb_vscyto3d_infectionft_dynacellft_mock.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_infectionft_dynacellft/eval_vscyto3d_infectionft_dynacellft_membrane_mock - name: a549_denv @@ -35,7 +33,7 @@ conditions: dataset: a549-mantis-caax-denv io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/dual_nucl_memb_vscyto3d_infectionft_dynacellft_denv.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_infectionft_dynacellft/eval_vscyto3d_infectionft_dynacellft_membrane_denv - name: a549_zikv @@ -44,6 +42,6 @@ conditions: dataset: a549-mantis-caax-zikv io: pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/dual_nucl_memb_vscyto3d_infectionft_dynacellft_zikv.zarr - nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr save: save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_infectionft_dynacellft/eval_vscyto3d_infectionft_dynacellft_membrane_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_infectionft_dynacellft/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_infectionft_dynacellft/ipsc_confocal/eval__ipsc_confocal.yaml index d7b9e60c0..9da0cae8c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_infectionft_dynacellft/ipsc_confocal/eval__ipsc_confocal.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/membrane/vscyto3d_infectionft_dynacellft/ipsc_confocal/eval__ipsc_confocal.yaml @@ -11,10 +11,8 @@ io: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose_watershed + backend: cpdino nuclei_channel_name: Nuclei - watershed: - subtract_nuclei: false save: save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_infectionft_dynacellft/eval_vscyto3d_infectionft_dynacellft_membrane diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index f11672d97..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../mito/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index 36476fb4e..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../mito/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index ff457651d..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../mito/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 120000 index de8318344..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../mito/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index 58d6f5ef9..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index d9abc8a70..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index 672c4b9b7..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index 1011b8fbe..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index 37f841983..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index fdddfb41f..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index 7023b987f..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index 665a14a37..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index f6803af88..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/phase/eval__a549_mantis_tomm20_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/phase/eval__a549_mantis_tomm20_denv.yaml new file mode 100644 index 000000000..8db59c887 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/phase/eval__a549_mantis_tomm20_denv.yaml @@ -0,0 +1,21 @@ +# @package _global_ +# Phase baseline (no model): the raw Phase3D input scored as the "prediction" +# against the A549 denv MITO (tomm20) GT. io.pred_is_source reads Phase3D and +# defaults io.pred_path to the GT store, so positions match by construction. +# Diffuse organelle: supermodel semantic + manifest cell_segmentation_path +# (no cpdino backend / instance AP, unlike the nucleus/membrane phase leaves). +defaults: + - override /target: mito_tomm20 + - override /predict_set: a549_mantis_tomm20_denv + +benchmark: + dataset_ref: + target: tomm20 + +io: + pred_is_source: true + +compute_feature_metrics: true + +save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_phase_mitochondria_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/phase/eval__a549_mantis_tomm20_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/phase/eval__a549_mantis_tomm20_mock.yaml new file mode 100644 index 000000000..f6cf87552 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/phase/eval__a549_mantis_tomm20_mock.yaml @@ -0,0 +1,21 @@ +# @package _global_ +# Phase baseline (no model): the raw Phase3D input scored as the "prediction" +# against the A549 mock MITO (tomm20) GT. io.pred_is_source reads Phase3D and +# defaults io.pred_path to the GT store, so positions match by construction. +# Diffuse organelle: supermodel semantic + manifest cell_segmentation_path +# (no cpdino backend / instance AP, unlike the nucleus/membrane phase leaves). +defaults: + - override /target: mito_tomm20 + - override /predict_set: a549_mantis_tomm20_mock + +benchmark: + dataset_ref: + target: tomm20 + +io: + pred_is_source: true + +compute_feature_metrics: true + +save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_phase_mitochondria_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/phase/eval__a549_mantis_tomm20_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/phase/eval__a549_mantis_tomm20_zikv.yaml new file mode 100644 index 000000000..fc87dd855 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/phase/eval__a549_mantis_tomm20_zikv.yaml @@ -0,0 +1,21 @@ +# @package _global_ +# Phase baseline (no model): the raw Phase3D input scored as the "prediction" +# against the A549 zikv MITO (tomm20) GT. io.pred_is_source reads Phase3D and +# defaults io.pred_path to the GT store, so positions match by construction. +# Diffuse organelle: supermodel semantic + manifest cell_segmentation_path +# (no cpdino backend / instance AP, unlike the nucleus/membrane phase leaves). +defaults: + - override /target: mito_tomm20 + - override /predict_set: a549_mantis_tomm20_zikv + +benchmark: + dataset_ref: + target: tomm20 + +io: + pred_is_source: true + +compute_feature_metrics: true + +save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_phase_mitochondria_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/phase/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/phase/eval__ipsc_confocal.yaml new file mode 100644 index 000000000..4039d78d0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/phase/eval__ipsc_confocal.yaml @@ -0,0 +1,16 @@ +# @package _global_ +# Phase baseline (no model): the raw Phase3D input scored as the "prediction" +# against the iPSC MITO GT. io.pred_is_source reads the manifest source +# channel (Phase3D) and defaults io.pred_path to the GT store. Diffuse organelle: +# supermodel semantic + manifest cell_segmentation_path (no cpdino / instance AP). +defaults: + - override /target: mito_tomm20 + - override /predict_set: ipsc_confocal + +io: + pred_is_source: true + +compute_feature_metrics: true + +save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_phase_mitochondria diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index 9b19caf19..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../mito/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index 8450554cc..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../mito/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index ec036b12a..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../mito/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 120000 index 8438345ae..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/mito/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../mito/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index 8edc2a391..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../nucleus/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index 160a32964..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../nucleus/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index fb805e3ca..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../nucleus/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 120000 index c530b0717..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../nucleus/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index 09d15f98d..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index 8d160143e..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index 131a499e5..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_cytoland/cytoland/eval__a549_mantis.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_cytoland/cytoland/eval__a549_mantis.yaml index bcdb315ee..7a9b23595 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_cytoland/cytoland/eval__a549_mantis.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_cytoland/cytoland/eval__a549_mantis.yaml @@ -14,7 +14,7 @@ benchmark: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose + backend: cpdino conditions: - name: a549_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_cytoland/cytoland/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_cytoland/cytoland/eval__ipsc_confocal.yaml index e1d1eb4c7..4f07a87b9 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_cytoland/cytoland/eval__ipsc_confocal.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_cytoland/cytoland/eval__ipsc_confocal.yaml @@ -12,7 +12,7 @@ io: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose + backend: cpdino save: save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_vscyto3d_cytoland_nucleus diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_infectionft/infectionft/eval__a549_mantis.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_infectionft/infectionft/eval__a549_mantis.yaml index e547af8e0..6052242ee 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_infectionft/infectionft/eval__a549_mantis.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_infectionft/infectionft/eval__a549_mantis.yaml @@ -14,7 +14,7 @@ benchmark: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose + backend: cpdino conditions: - name: a549_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_infectionft/infectionft/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_infectionft/infectionft/eval__ipsc_confocal.yaml index 2643ae054..4757c6192 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_infectionft/infectionft/eval__ipsc_confocal.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_infectionft/infectionft/eval__ipsc_confocal.yaml @@ -12,7 +12,7 @@ io: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose + backend: cpdino save: save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_vscyto3d_infectionft_nucleus diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_randinit/randinit/eval__a549_mantis.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_randinit/randinit/eval__a549_mantis.yaml index 68c8c6d85..ba1302383 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_randinit/randinit/eval__a549_mantis.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_randinit/randinit/eval__a549_mantis.yaml @@ -15,7 +15,7 @@ benchmark: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose + backend: cpdino conditions: - name: a549_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_randinit/randinit/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_randinit/randinit/eval__ipsc_confocal.yaml index 80755dc51..85c286fb0 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_randinit/randinit/eval__ipsc_confocal.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_pretrained_randinit/randinit/eval__ipsc_confocal.yaml @@ -12,7 +12,7 @@ io: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose + backend: cpdino save: save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_vscyto3d_randinit_nucleus diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index d97f17296..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index e14458f48..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index 847aa1ad0..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index eada00bf5..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index 1071d3912..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index 524868764..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/phase/eval__a549_mantis_h2b_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/phase/eval__a549_mantis_h2b_denv.yaml new file mode 100644 index 000000000..cb44251b7 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/phase/eval__a549_mantis_h2b_denv.yaml @@ -0,0 +1,22 @@ +# @package _global_ +# Phase baseline (no model): raw Phase3D input scored as the "prediction" against +# the A549 denv nucleus (H2B) GT. io.pred_is_source reads Phase3D and defaults +# io.pred_path to the GT store (H2B_denv.ozx), so positions match by construction. +defaults: + - override /target: nucleus + - override /predict_set: a549_mantis_h2b_denv + +benchmark: + dataset_ref: + target: h2b + +io: + pred_is_source: true + +compute_feature_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino + +save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_phase_nucleus_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/phase/eval__a549_mantis_h2b_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/phase/eval__a549_mantis_h2b_mock.yaml new file mode 100644 index 000000000..6b97dda19 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/phase/eval__a549_mantis_h2b_mock.yaml @@ -0,0 +1,22 @@ +# @package _global_ +# Phase baseline (no model): raw Phase3D input scored as the "prediction" against +# the A549 mock nucleus (H2B) GT. io.pred_is_source reads Phase3D and defaults +# io.pred_path to the GT store (H2B_mock.ozx), so positions match by construction. +defaults: + - override /target: nucleus + - override /predict_set: a549_mantis_h2b_mock + +benchmark: + dataset_ref: + target: h2b + +io: + pred_is_source: true + +compute_feature_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino + +save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_phase_nucleus_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/phase/eval__a549_mantis_h2b_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/phase/eval__a549_mantis_h2b_zikv.yaml new file mode 100644 index 000000000..4563aa389 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/phase/eval__a549_mantis_h2b_zikv.yaml @@ -0,0 +1,22 @@ +# @package _global_ +# Phase baseline (no model): raw Phase3D input scored as the "prediction" against +# the A549 zikv nucleus (H2B) GT. io.pred_is_source reads Phase3D and defaults +# io.pred_path to the GT store (H2B_zikv.ozx), so positions match by construction. +defaults: + - override /target: nucleus + - override /predict_set: a549_mantis_h2b_zikv + +benchmark: + dataset_ref: + target: h2b + +io: + pred_is_source: true + +compute_feature_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino + +save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/evaluations_with_embeddings/eval_phase_nucleus_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/phase/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/phase/eval__ipsc_confocal.yaml new file mode 100644 index 000000000..6f2b964cb --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/phase/eval__ipsc_confocal.yaml @@ -0,0 +1,19 @@ +# @package _global_ +# Phase baseline (no model): the raw Phase3D input scored as the "prediction" +# against the iPSC nucleus GT. io.pred_is_source reads the manifest source channel +# (Phase3D) and defaults io.pred_path to the GT store (cell.zarr), so pred/GT +# positions match by construction. cpdino segments the phase image for instance AP. +defaults: + - override /target: nucleus + - override /predict_set: ipsc_confocal + +io: + pred_is_source: true + +compute_feature_metrics: true +compute_instance_ap: true +segmentation: + backend: cpdino + +save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_with_embeddings/eval_phase_nucleus diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 120000 index 1715307a0..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 120000 index 019928b53..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 120000 index 6025b9bf4..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 120000 index 6fa52b633..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1 +0,0 @@ -../../../../../nucleus/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml \ No newline at end of file diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_cytolandft/a549_mantis/eval__a549_mantis.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_cytolandft/a549_mantis/eval__a549_mantis.yaml index dfd65cd7d..e04dd2eb5 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_cytolandft/a549_mantis/eval__a549_mantis.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_cytolandft/a549_mantis/eval__a549_mantis.yaml @@ -14,7 +14,7 @@ benchmark: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose + backend: cpdino conditions: - name: a549_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_cytolandft/a549_mantis/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_cytolandft/a549_mantis/eval__ipsc_confocal.yaml index 9c7f32c07..c4f48ef0f 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_cytolandft/a549_mantis/eval__ipsc_confocal.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_cytolandft/a549_mantis/eval__ipsc_confocal.yaml @@ -11,7 +11,7 @@ io: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose + backend: cpdino save: save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_cytolandft_a549trained/eval_vscyto3d_cytolandft_a549trained_nucleus diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_cytolandft/ipsc_confocal/eval__a549_mantis.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_cytolandft/ipsc_confocal/eval__a549_mantis.yaml index 4b3bc9c58..214835aae 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_cytolandft/ipsc_confocal/eval__a549_mantis.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_cytolandft/ipsc_confocal/eval__a549_mantis.yaml @@ -14,7 +14,7 @@ benchmark: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose + backend: cpdino conditions: - name: a549_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_cytolandft/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_cytolandft/ipsc_confocal/eval__ipsc_confocal.yaml index 59328cc79..9b6857fa0 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_cytolandft/ipsc_confocal/eval__ipsc_confocal.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_cytolandft/ipsc_confocal/eval__ipsc_confocal.yaml @@ -11,7 +11,7 @@ io: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose + backend: cpdino save: save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_cytolandft/eval_vscyto3d_cytolandft_nucleus diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_infectionft_dynacellft/a549_mantis/eval__a549_mantis.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_infectionft_dynacellft/a549_mantis/eval__a549_mantis.yaml index 2d79cb35f..fea5aa23e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_infectionft_dynacellft/a549_mantis/eval__a549_mantis.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_infectionft_dynacellft/a549_mantis/eval__a549_mantis.yaml @@ -14,7 +14,7 @@ benchmark: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose + backend: cpdino conditions: - name: a549_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_infectionft_dynacellft/a549_mantis/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_infectionft_dynacellft/a549_mantis/eval__ipsc_confocal.yaml index 1a5376f0b..8b4083036 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_infectionft_dynacellft/a549_mantis/eval__ipsc_confocal.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_infectionft_dynacellft/a549_mantis/eval__ipsc_confocal.yaml @@ -11,7 +11,7 @@ io: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose + backend: cpdino save: save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_infectionft_dynacellft_a549trained/eval_vscyto3d_infectionft_dynacellft_a549trained_nucleus diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_infectionft_dynacellft/ipsc_confocal/eval__a549_mantis.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_infectionft_dynacellft/ipsc_confocal/eval__a549_mantis.yaml index 435a00db6..e30881044 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_infectionft_dynacellft/ipsc_confocal/eval__a549_mantis.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_infectionft_dynacellft/ipsc_confocal/eval__a549_mantis.yaml @@ -14,7 +14,7 @@ benchmark: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose + backend: cpdino conditions: - name: a549_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_infectionft_dynacellft/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_infectionft_dynacellft/ipsc_confocal/eval__ipsc_confocal.yaml index 22fbc472f..29261d628 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_infectionft_dynacellft/ipsc_confocal/eval__ipsc_confocal.yaml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/nucleus/vscyto3d_infectionft_dynacellft/ipsc_confocal/eval__ipsc_confocal.yaml @@ -11,7 +11,7 @@ io: compute_feature_metrics: true compute_instance_ap: true segmentation: - backend: cellpose + backend: cpdino save: save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/evaluations_infectionft_dynacellft/eval_vscyto3d_infectionft_dynacellft_nucleus diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_a549_trained__a549_denv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_a549_trained__a549_denv/eval_grouped.yaml new file mode 100644 index 000000000..427b98452 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_a549_trained__a549_denv/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__a549_trained__a549_denv' lifted from +# grouped/er_a549_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix3d_unetvit/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_a549_trained__a549_mock/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_a549_trained__a549_mock/eval_grouped.yaml new file mode 100644 index 000000000..d25ea6011 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_a549_trained__a549_mock/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__a549_trained__a549_mock' lifted from +# grouped/er_a549_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix3d_unetvit/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_a549_trained__a549_zikv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_a549_trained__a549_zikv/eval_grouped.yaml new file mode 100644 index 000000000..039d12480 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_a549_trained__a549_zikv/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__a549_trained__a549_zikv' lifted from +# grouped/er_a549_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix3d_unetvit/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_a549_trained__ipsc/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_a549_trained__ipsc/eval_grouped.yaml new file mode 100644 index 000000000..a3bdabad8 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_a549_trained__ipsc/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__a549_trained__ipsc' lifted from +# grouped/er_a549_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/pix2pix3d_unetvit/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_ipsc_trained__a549_denv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_ipsc_trained__a549_denv/eval_grouped.yaml new file mode 100644 index 000000000..7fb42278c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_ipsc_trained__a549_denv/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__ipsc_trained__a549_denv' lifted from +# grouped/er_ipsc_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix3d_unetvit/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_ipsc_trained__a549_mock/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_ipsc_trained__a549_mock/eval_grouped.yaml new file mode 100644 index 000000000..3067888db --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_ipsc_trained__a549_mock/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__ipsc_trained__a549_mock' lifted from +# grouped/er_ipsc_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix3d_unetvit/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_ipsc_trained__a549_zikv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_ipsc_trained__a549_zikv/eval_grouped.yaml new file mode 100644 index 000000000..cfe0904b4 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_ipsc_trained__a549_zikv/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__ipsc_trained__a549_zikv' lifted from +# grouped/er_ipsc_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix3d_unetvit/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_ipsc_trained__ipsc/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_ipsc_trained__ipsc/eval_grouped.yaml new file mode 100644 index 000000000..94a6becad --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_ipsc_trained__ipsc/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__ipsc_trained__ipsc' lifted from +# grouped/er_ipsc_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/pix2pix3d_unetvit/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_joint__a549_denv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_joint__a549_denv/eval_grouped.yaml new file mode 100644 index 000000000..46adc0a58 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_joint__a549_denv/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__joint__a549_denv' lifted from +# grouped/er_joint. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-denv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix3d_unetvit/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_joint__a549_mock/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_joint__a549_mock/eval_grouped.yaml new file mode 100644 index 000000000..3c6a33b4f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_joint__a549_mock/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__joint__a549_mock' lifted from +# grouped/er_joint. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-mock + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix3d_unetvit/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_joint__a549_zikv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_joint__a549_zikv/eval_grouped.yaml new file mode 100644 index 000000000..3a8f1e933 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_joint__a549_zikv/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__joint__a549_zikv' lifted from +# grouped/er_joint. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-sec61b-zikv + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/er/pix2pix3d_unetvit/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_joint__ipsc/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_joint__ipsc/eval_grouped.yaml new file mode 100644 index 000000000..b9f244e05 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/er_joint__ipsc/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__joint__ipsc' lifted from +# grouped/er_joint. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: er +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: sec61b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/er/pix2pix3d_unetvit/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_a549_trained__a549_denv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_a549_trained__a549_denv/eval_grouped.yaml new file mode 100644 index 000000000..092ea4fa3 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_a549_trained__a549_denv/eval_grouped.yaml @@ -0,0 +1,41 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__a549_trained__a549_denv' lifted from +# grouped/membrane_a549_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +conditions: +- name: pix2pix3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix3d_unetvit/a549/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_a549_trained__a549_mock/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_a549_trained__a549_mock/eval_grouped.yaml new file mode 100644 index 000000000..8b5106fdb --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_a549_trained__a549_mock/eval_grouped.yaml @@ -0,0 +1,41 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__a549_trained__a549_mock' lifted from +# grouped/membrane_a549_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +conditions: +- name: pix2pix3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix3d_unetvit/a549/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_a549_trained__a549_zikv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_a549_trained__a549_zikv/eval_grouped.yaml new file mode 100644 index 000000000..6143a8916 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_a549_trained__a549_zikv/eval_grouped.yaml @@ -0,0 +1,41 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__a549_trained__a549_zikv' lifted from +# grouped/membrane_a549_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +conditions: +- name: pix2pix3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix3d_unetvit/a549/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_a549_trained__ipsc/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_a549_trained__ipsc/eval_grouped.yaml new file mode 100644 index 000000000..05f5d93f4 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_a549_trained__ipsc/eval_grouped.yaml @@ -0,0 +1,40 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__a549_trained__ipsc' lifted from +# grouped/membrane_a549_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +conditions: +- name: pix2pix3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/pix2pix3d_unetvit/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_ipsc_trained__a549_denv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_ipsc_trained__a549_denv/eval_grouped.yaml new file mode 100644 index 000000000..c5fe94952 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_ipsc_trained__a549_denv/eval_grouped.yaml @@ -0,0 +1,41 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__ipsc_trained__a549_denv' lifted from +# grouped/membrane_ipsc_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +conditions: +- name: pix2pix3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix3d_unetvit/ipsc/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_ipsc_trained__a549_mock/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_ipsc_trained__a549_mock/eval_grouped.yaml new file mode 100644 index 000000000..d28e65b21 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_ipsc_trained__a549_mock/eval_grouped.yaml @@ -0,0 +1,41 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__ipsc_trained__a549_mock' lifted from +# grouped/membrane_ipsc_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +conditions: +- name: pix2pix3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix3d_unetvit/ipsc/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_ipsc_trained__a549_zikv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_ipsc_trained__a549_zikv/eval_grouped.yaml new file mode 100644 index 000000000..fe590aaf8 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_ipsc_trained__a549_zikv/eval_grouped.yaml @@ -0,0 +1,41 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__ipsc_trained__a549_zikv' lifted from +# grouped/membrane_ipsc_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +conditions: +- name: pix2pix3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix3d_unetvit/ipsc/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_ipsc_trained__ipsc/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_ipsc_trained__ipsc/eval_grouped.yaml new file mode 100644 index 000000000..1cd36cf78 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_ipsc_trained__ipsc/eval_grouped.yaml @@ -0,0 +1,40 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__ipsc_trained__ipsc' lifted from +# grouped/membrane_ipsc_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +conditions: +- name: pix2pix3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/pix2pix3d_unetvit/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_joint__a549_denv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_joint__a549_denv/eval_grouped.yaml new file mode 100644 index 000000000..bc983df53 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_joint__a549_denv/eval_grouped.yaml @@ -0,0 +1,41 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__joint__a549_denv' lifted from +# grouped/membrane_joint. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +conditions: +- name: pix2pix3d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-denv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix3d_unetvit/joint/a549__denv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_joint__a549_mock/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_joint__a549_mock/eval_grouped.yaml new file mode 100644 index 000000000..adba129a0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_joint__a549_mock/eval_grouped.yaml @@ -0,0 +1,41 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__joint__a549_mock' lifted from +# grouped/membrane_joint. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +conditions: +- name: pix2pix3d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-caax-mock + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix3d_unetvit/joint/a549__mock + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_joint__a549_zikv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_joint__a549_zikv/eval_grouped.yaml new file mode 100644 index 000000000..bf4911f6e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_joint__a549_zikv/eval_grouped.yaml @@ -0,0 +1,41 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__joint__a549_zikv' lifted from +# grouped/membrane_joint. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +conditions: +- name: pix2pix3d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-caax-zikv + target: caax + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/membrane/pix2pix3d_unetvit/joint/a549__zikv + nuclei_gt_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_joint__ipsc/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_joint__ipsc/eval_grouped.yaml new file mode 100644 index 000000000..faad050e6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/membrane_joint__ipsc/eval_grouped.yaml @@ -0,0 +1,40 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__joint__ipsc' lifted from +# grouped/membrane_joint. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: membrane +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino + nuclei_channel_name: Nuclei +conditions: +- name: pix2pix3d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: membrane + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/membrane/pix2pix3d_unetvit/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_a549_trained__a549_denv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_a549_trained__a549_denv/eval_grouped.yaml new file mode 100644 index 000000000..f4f456819 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_a549_trained__a549_denv/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__a549_trained__a549_denv' lifted from +# grouped/mitochondria_a549_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix3d_unetvit/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_a549_trained__a549_mock/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_a549_trained__a549_mock/eval_grouped.yaml new file mode 100644 index 000000000..582b70948 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_a549_trained__a549_mock/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__a549_trained__a549_mock' lifted from +# grouped/mitochondria_a549_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix3d_unetvit/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_a549_trained__a549_zikv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_a549_trained__a549_zikv/eval_grouped.yaml new file mode 100644 index 000000000..a5221e9f5 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_a549_trained__a549_zikv/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__a549_trained__a549_zikv' lifted from +# grouped/mitochondria_a549_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix3d_unetvit/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_a549_trained__ipsc/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_a549_trained__ipsc/eval_grouped.yaml new file mode 100644 index 000000000..65ed64ee6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_a549_trained__ipsc/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__a549_trained__ipsc' lifted from +# grouped/mitochondria_a549_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/pix2pix3d_unetvit/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_ipsc_trained__a549_denv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_ipsc_trained__a549_denv/eval_grouped.yaml new file mode 100644 index 000000000..11b381e0a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_ipsc_trained__a549_denv/eval_grouped.yaml @@ -0,0 +1,37 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__ipsc_trained__a549_denv' lifted from +# grouped/mitochondria_ipsc_trained. This arm had no prediction at all before the +# fix batch (the iPSC-trained mito pix2pix predicts were generated 2026-07-28/29), +# so this is a first evaluation rather than a re-eval; the pred-side force flags +# are kept identical to the other 44 leaves so every pix2pix cell in the tables +# comes from one pipeline. GT-side flags stay false: the GT cache is prewarmed +# and read-only here. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix3d_unetvit/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_ipsc_trained__a549_mock/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_ipsc_trained__a549_mock/eval_grouped.yaml new file mode 100644 index 000000000..6ff0322bc --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_ipsc_trained__a549_mock/eval_grouped.yaml @@ -0,0 +1,42 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__ipsc_trained__a549_mock' lifted from +# grouped/mitochondria_ipsc_trained. This arm had no prediction at all before the +# fix batch (the iPSC-trained mito pix2pix predicts were generated 2026-07-28/29), +# so this is a first evaluation rather than a re-eval; the pred-side force flags +# are kept identical to the other 44 leaves so every pix2pix cell in the tables +# comes from one pipeline. GT-side flags stay false: the GT cache is prewarmed +# and read-only here. +# +# This is the last of the four; its predict ran far slower than its siblings +# (~15 h vs ~9 h), so it is submitted with an afterok dependency on that job +# rather than by hand. It is also the group's mock reference, so the mito/ipsc +# infection probe cannot be computed for ANY condition until this lands. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix3d_unetvit/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_ipsc_trained__a549_zikv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_ipsc_trained__a549_zikv/eval_grouped.yaml new file mode 100644 index 000000000..97cdbdb1f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_ipsc_trained__a549_zikv/eval_grouped.yaml @@ -0,0 +1,37 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__ipsc_trained__a549_zikv' lifted from +# grouped/mitochondria_ipsc_trained. This arm had no prediction at all before the +# fix batch (the iPSC-trained mito pix2pix predicts were generated 2026-07-28/29), +# so this is a first evaluation rather than a re-eval; the pred-side force flags +# are kept identical to the other 44 leaves so every pix2pix cell in the tables +# comes from one pipeline. GT-side flags stay false: the GT cache is prewarmed +# and read-only here. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix3d_unetvit/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_ipsc_trained__ipsc/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_ipsc_trained__ipsc/eval_grouped.yaml new file mode 100644 index 000000000..2c63c0e4c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_ipsc_trained__ipsc/eval_grouped.yaml @@ -0,0 +1,37 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__ipsc_trained__ipsc' lifted from +# grouped/mitochondria_ipsc_trained. This arm had no prediction at all before the +# fix batch (the iPSC-trained mito pix2pix predicts were generated 2026-07-28/29), +# so this is a first evaluation rather than a re-eval; the pred-side force flags +# are kept identical to the other 44 leaves so every pix2pix cell in the tables +# comes from one pipeline. GT-side flags stay false: the GT cache is prewarmed +# and read-only here. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/pix2pix3d_unetvit/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_joint__a549_denv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_joint__a549_denv/eval_grouped.yaml new file mode 100644 index 000000000..2dd440c88 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_joint__a549_denv/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__joint__a549_denv' lifted from +# grouped/mitochondria_joint. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-denv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix3d_unetvit/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_joint__a549_mock/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_joint__a549_mock/eval_grouped.yaml new file mode 100644 index 000000000..e93b8bd9f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_joint__a549_mock/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__joint__a549_mock' lifted from +# grouped/mitochondria_joint. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-mock + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix3d_unetvit/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_joint__a549_zikv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_joint__a549_zikv/eval_grouped.yaml new file mode 100644 index 000000000..13a443da6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_joint__a549_zikv/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__joint__a549_zikv' lifted from +# grouped/mitochondria_joint. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-tomm20-zikv + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/mito/pix2pix3d_unetvit/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_joint__ipsc/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_joint__ipsc/eval_grouped.yaml new file mode 100644 index 000000000..50a5f190c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/mitochondria_joint__ipsc/eval_grouped.yaml @@ -0,0 +1,36 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__joint__ipsc' lifted from +# grouped/mitochondria_joint. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: mitochondria +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +conditions: +- name: pix2pix3d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: tomm20 + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/mito/pix2pix3d_unetvit/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_a549_trained__a549_denv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_a549_trained__a549_denv/eval_grouped.yaml new file mode 100644 index 000000000..4f3b08cab --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_a549_trained__a549_denv/eval_grouped.yaml @@ -0,0 +1,39 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__a549_trained__a549_denv' lifted from +# grouped/nucleus_a549_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: pix2pix3d__a549_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix3d_unetvit/a549/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_a549_trained__a549_mock/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_a549_trained__a549_mock/eval_grouped.yaml new file mode 100644 index 000000000..05b630de3 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_a549_trained__a549_mock/eval_grouped.yaml @@ -0,0 +1,39 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__a549_trained__a549_mock' lifted from +# grouped/nucleus_a549_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: pix2pix3d__a549_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix3d_unetvit/a549/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_a549_trained__a549_zikv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_a549_trained__a549_zikv/eval_grouped.yaml new file mode 100644 index 000000000..14691e4d4 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_a549_trained__a549_zikv/eval_grouped.yaml @@ -0,0 +1,39 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__a549_trained__a549_zikv' lifted from +# grouped/nucleus_a549_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: pix2pix3d__a549_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix3d_unetvit/a549/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_a549_trained__ipsc/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_a549_trained__ipsc/eval_grouped.yaml new file mode 100644 index 000000000..871164a5f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_a549_trained__ipsc/eval_grouped.yaml @@ -0,0 +1,39 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__a549_trained__ipsc' lifted from +# grouped/nucleus_a549_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: pix2pix3d__a549_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/pix2pix3d_unetvit/a549/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_ipsc_trained__a549_denv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_ipsc_trained__a549_denv/eval_grouped.yaml new file mode 100644 index 000000000..640d448a6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_ipsc_trained__a549_denv/eval_grouped.yaml @@ -0,0 +1,39 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__ipsc_trained__a549_denv' lifted from +# grouped/nucleus_ipsc_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: pix2pix3d__ipsc_trained__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix3d_unetvit/ipsc/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_ipsc_trained__a549_mock/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_ipsc_trained__a549_mock/eval_grouped.yaml new file mode 100644 index 000000000..5cfd71b46 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_ipsc_trained__a549_mock/eval_grouped.yaml @@ -0,0 +1,39 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__ipsc_trained__a549_mock' lifted from +# grouped/nucleus_ipsc_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: pix2pix3d__ipsc_trained__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix3d_unetvit/ipsc/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_ipsc_trained__a549_zikv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_ipsc_trained__a549_zikv/eval_grouped.yaml new file mode 100644 index 000000000..fff856566 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_ipsc_trained__a549_zikv/eval_grouped.yaml @@ -0,0 +1,39 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__ipsc_trained__a549_zikv' lifted from +# grouped/nucleus_ipsc_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: pix2pix3d__ipsc_trained__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix3d_unetvit/ipsc/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_ipsc_trained__ipsc/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_ipsc_trained__ipsc/eval_grouped.yaml new file mode 100644 index 000000000..b6b524f77 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_ipsc_trained__ipsc/eval_grouped.yaml @@ -0,0 +1,39 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__ipsc_trained__ipsc' lifted from +# grouped/nucleus_ipsc_trained. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: pix2pix3d__ipsc_trained__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/pix2pix3d_unetvit/ipsc/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_joint__a549_denv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_joint__a549_denv/eval_grouped.yaml new file mode 100644 index 000000000..3c2dff753 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_joint__a549_denv/eval_grouped.yaml @@ -0,0 +1,39 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__joint__a549_denv' lifted from +# grouped/nucleus_joint. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: pix2pix3d__joint__a549_denv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-denv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__denv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix3d_unetvit/joint/a549__denv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_joint__a549_mock/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_joint__a549_mock/eval_grouped.yaml new file mode 100644 index 000000000..240df2bae --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_joint__a549_mock/eval_grouped.yaml @@ -0,0 +1,39 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__joint__a549_mock' lifted from +# grouped/nucleus_joint. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: pix2pix3d__joint__a549_mock + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-mock + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__mock/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix3d_unetvit/joint/a549__mock + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_joint__a549_zikv/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_joint__a549_zikv/eval_grouped.yaml new file mode 100644 index 000000000..1b3661b86 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_joint__a549_zikv/eval_grouped.yaml @@ -0,0 +1,39 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__joint__a549_zikv' lifted from +# grouped/nucleus_joint. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: pix2pix3d__joint__a549_zikv + benchmark: + dataset_ref: + dataset: a549-mantis-h2b-zikv + target: h2b + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__zikv/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache_pred/nucleus/pix2pix3d_unetvit/joint/a549__zikv + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_joint__ipsc/eval_grouped.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_joint__ipsc/eval_grouped.yaml new file mode 100644 index 000000000..666077a3e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/leaf/pix2pix_reeval/nucleus_joint__ipsc/eval_grouped.yaml @@ -0,0 +1,39 @@ +# @package _global_ +# pix2pix3d re-eval leaf: single condition 'pix2pix3d__joint__ipsc' lifted from +# grouped/nucleus_joint. Forces every pred-side artifact family because the +# prediction zarr was rewritten in place (no content fingerprinting, so +# the cache identity is unchanged and nothing auto-invalidates). GT-side +# flags stay false: the GT cache is prewarmed and read-only here. +# Generated by scratchpad/gen_pix2pix_reeval.py. +target_name: nucleus +compute_feature_metrics: true +use_gpu: true +io: + require_complete_cache: false +runtime: + executor: serial + fov_workers: 1 + threads_per_worker: auto +force_recompute: + final_metrics: true + pred_masks: true + pred_cp: true + pred_dinov3: true + pred_dynaclr: true + pred_celldino: true + pred_morphem: true + pred_instances: true +compute_instance_ap: true +segmentation: + backend: cpdino +conditions: +- name: pix2pix3d__joint__ipsc + benchmark: + dataset_ref: + dataset: aics-hipsc + target: nucleus + io: + pred_path: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/ipsc/prediction.zarr + pred_cache_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/eval_cache_pred/nucleus/pix2pix3d_unetvit/joint/ipsc + save: + save_dir: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/celldiff_2d_fit.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/celldiff_2d_fit.yml new file mode 100644 index 000000000..73f276c03 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/celldiff_2d_fit.yml @@ -0,0 +1,78 @@ +# CellDiff-2D fit-time HCS data hparams for the in-focus 2D benchmark +# track. Split out from model_overlays/celldiff_2d_fit.yml so the +# model+trainer half there stays composable by joint-dataset +# (BatchedConcatDataModule) leaves that author their own data: block. +# +# Mirrors data_overlays/celldiff_fit.yml but flattens Z onto the offline +# `_focus.zarr` 5-plane in-focus slab stores (z_window_size=1, each window +# one plane), following the same convention as +# data_overlays/fcmae_vscyto2d_fit.yml: +# - z_window_size: 13 -> 1 +# - BatchedRandAffined rotate_range [3.14,0,0] -> [0,0,0] (rotation about +# axis 0 mixes Y and Z, which is degenerate at Z=1) +# - BatchedRandAffined scale_range Z [0.7,1.3] -> [1,1] (kornia affine +# scale is an absolute factor, so 1.0 is the no-op, not 0) +# - safe_crop_size / roi_size [8,512,512] -> [1,512,512] +# - BatchedRandGaussianSmoothd sigma_z [0.25,0.75] -> [0,0] +# XY augmentation policy (shear/scale/contrast/intensity/noise/smooth) is +# kept identical to the 3D overlay so 2D-vs-3D isolates geometry. +# +# batch_size stays 4, matching the 3D CellDiff leaf. Measured peak on an +# A40 (44.7 GiB) at [1,512,512] with bf16 autocast + AdamW: bs=4 -> 14.7 GiB +# (33%), bs=8 -> 28.2 GiB (63%), bs=16 -> OOM. hardware_gpu_any_long sets +# `constraint: null`, so a leaf can land on a 24 GB card — bs=8 would not +# fit there. Raise batch_size only together with a >=48 GB constraint. +data: + init_args: + z_window_size: 1 + batch_size: 4 + num_workers: 4 + yx_patch_size: [512, 512] + gpu_augmentations: + # GPU: affine on oversized patch → center crop to final 1×512×512. + # safe_crop_size clamps scale so the sheared/scaled source always + # covers the 512px crop, eliminating zero-corner artifacts. + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [0, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[1, 1], [0.5, 1.5], [0.5, 1.5]] + safe_crop_size: [1, 512, 512] + safe_crop_coverage: 0.9 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0, 0] + val_gpu_augmentations: + # CellDiff requires exact input_spatial_size (fixed ViT positional + # embeddings). DivisibleCropd is insufficient — must center-crop to + # exactly the model input size. + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml new file mode 100644 index 000000000..d076cc03d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml @@ -0,0 +1,78 @@ +# FCMAE-2D (VSCyto2D-geometry FullyConvolutionalMAE) fit-time HCS data +# hparams for the in-focus 2D benchmark track. Split out from +# model_overlays/fcmae_vscyto2d_fit.yml so the model+trainer half there +# stays composable by joint-dataset (BatchedConcatDataModule) leaves that +# author their own data: block. +# +# Mirrors data_overlays/fcmae_vscyto3d_fit.yml but flattens all Z +# augmentations to the cytoland 2D convention (z_window_size=1 reads the +# offline `_focus.zarr` 5-plane slab stores; each window is one plane): +# - z_window_size: 20 -> 1 +# - RandWeightedCropd spatial_size [20,600,600] -> [1,600,600] +# - BatchedRandAffined rotate_range [3.14,0,0] -> [0,0,0], +# scale_range Z [0.7,1.3] -> [1,1] (identity = no Z scale; kornia +# affine scale is an absolute factor, so 1.0 is the no-op, not 0) +# - BatchedCenterSpatialCropd roi_size [15,384,384] -> [1,384,384] +# - BatchedRandGaussianSmoothd sigma_z [0.25,0.75] -> [0,0] +# XY augmentation policy (shear/scale/contrast/intensity/noise/smooth) is +# kept identical to the 3D overlay. +data: + init_args: + z_window_size: 1 + # 16 (not the 3D overlay's 32) so a single_gpu fit fits the 48 GB pool + # (a40|l40s|a6000): bs=32 OOMs at ~47 GB there, bs=8 uses ~half, so 16 + # keeps ~2x headroom and constraint:null stays valid. Effective batch is + # deliberately not forced to match the 3D 4-GPU global batch — the 2D + # nets are trained to their own best on cheap hardware (plan Phase-B). + batch_size: 16 + num_workers: 4 + yx_patch_size: [384, 384] + augmentations: + # CPU weighted crop on the 5-plane focus slab: spatial_size Z=1 + # samples a single target-weighted plane per crop. + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 600, 600] + num_samples: 4 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [0, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[1, 1], [0.5, 1.5], [0.5, 1.5]] + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 384, 384] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0, 0] + val_gpu_augmentations: + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 384, 384] diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/fnet2d_fit.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/fnet2d_fit.yml new file mode 100644 index 000000000..996e2cbfb --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/fnet2d_fit.yml @@ -0,0 +1,58 @@ +# FNet2D fit-time HCS data hparams for the in-focus 2D benchmark track. +# Split out from model_overlays/fnet2d_fit.yml so the model+trainer half +# there stays composable by joint-dataset (BatchedConcatDataModule) +# leaves that author their own data: block. +# +# Mirrors data_overlays/fnet3d_paper_fit.yml (including the mean/std +# Structure normalization and the 8-crops-per-FOV sampling that diverge +# from the CellDiff/UNetViT conventions) but flattens Z to the in-focus +# `_focus.zarr` 5-plane slab stores (z_window_size=1, each window one +# plane): +# - z_window_size: 32 -> 1 +# - RandWeightedCropd spatial_size [32,64,64] -> [1,64,64] +# - CenterSpatialCropd (val) roi_size [32,64,64] -> [1,64,64] +# The YX flips are unchanged (spatial_axes 1=Y, 2=X are valid at Z=1). +data: + init_args: + z_window_size: 1 + batch_size: 48 + num_workers: 8 + yx_patch_size: [64, 64] + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Structure] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + # CPU: 8 patches per FOV (amortizes zarr decompression). + # batch_size=48 -> DataLoader loads 6 FOVs, each yields 8 patches = 48. + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 64, 64] + num_samples: 8 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandFlipd + init_args: + keys: [source, target] + spatial_axes: [1] + prob: 0.5 + - class_path: viscy_transforms.BatchedRandFlipd + init_args: + keys: [source, target] + spatial_axes: [2] + prob: 0.5 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Phase3D, Structure] + roi_size: [1, 64, 64] diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/fnet3d_bigpatch_fit.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/fnet3d_bigpatch_fit.yml new file mode 100644 index 000000000..6f2ca2264 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/fnet3d_bigpatch_fit.yml @@ -0,0 +1,73 @@ +# FNet3D "larger-patch, simple-augs" ablation fit-time HCS data hparams +# (Arm A of the patch-vs-augmentation split). +# +# Purpose: disentangle the two things that change when FNet3D adopts the +# VSCyto3D training regime — the larger 384x384 spatial patch, and the +# richer augmentation stack. This overlay applies ONLY the larger patch +# with FNet3D's own simple augmentations (axis flips), so: +# fnet3d_paper (64x64, flips) -> fnet3d_bigpatch (384x384, flips) +# isolates the patch-size effect, and +# fnet3d_bigpatch (384x384, flips) -> fnet3d_vscyto3daug (384x384, augs) +# isolates the augmentation effect. +# Geometry / batch / precision / model / optimizer are identical to +# fnet3d_vscyto3daug_fit.yml (paired), so Arm A vs Arm B differ ONLY in the +# gpu_augmentations stack. +# +# Geometry: FNet3D's depth-4 encoder needs Z divisible by 2**4=16, so +# in_stack_depth stays 32 and the CPU weighted crop takes [32, 384, 384] +# directly (no affine headroom is needed without the affine, so unlike +# fnet3d_vscyto3daug there is no 600->384 GPU center-crop — the CPU crop +# already yields the model input size). +# +# Structure-keyed like fnet3d_paper_fit.yml: single-set nucleus leaves +# list-replace normalizations + the CPU augmentation to re-key onto Nuclei. +# +# batch_size 8 (2 FOVs x num_samples=4) at bf16-mixed (set in the leaf); +# tuned from a single-GPU H200 smoke. Must match fnet3d_vscyto3daug_fit.yml. +data: + init_args: + z_window_size: 32 + batch_size: 8 + num_workers: 4 + yx_patch_size: [384, 384] + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Structure] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + # CPU: crop directly to the 384x384x32 model input (no affine + # headroom needed), weighted by target intensity. num_samples=4 + # matches fnet3d_vscyto3daug so the on-GPU batch math is identical. + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [32, 384, 384] + num_samples: 4 + gpu_augmentations: + # FNet3D's own simple augmentations: axis flips only (the fnet3d_paper + # policy). This is the ONLY difference from fnet3d_vscyto3daug_fit.yml. + - class_path: viscy_transforms.BatchedRandFlipd + init_args: + keys: [source, target] + spatial_axes: [1] + prob: 0.5 + - class_path: viscy_transforms.BatchedRandFlipd + init_args: + keys: [source, target] + spatial_axes: [2] + prob: 0.5 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Phase3D, Structure] + roi_size: [32, 384, 384] diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/fnet3d_vscyto3daug_fit.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/fnet3d_vscyto3daug_fit.yml new file mode 100644 index 000000000..4ad78f1db --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/fnet3d_vscyto3daug_fit.yml @@ -0,0 +1,105 @@ +# FNet3D "same-augmentations" OOD-ablation fit-time HCS data hparams. +# +# Tests the paper claim that FNet3D underperforms out-of-distribution +# because it does not use the augmentation stack the other virtual-staining +# models use. This overlay grafts the VSCyto3D (FCMAE) augmentation +# pipeline — the large weighted crop plus BatchedRandAffined / +# AdjustContrast / ScaleIntensity / GaussianNoise / GaussianSmooth — onto +# an otherwise-unchanged FNet3D fit. Model, optimizer, loss, schedule, +# max_steps, precision and mean/std normalization are all inherited from +# model_overlays/fnet3d_paper_fit.yml, so only the augmentations differ +# from fnet3d_paper and any OOD change attributes to augmentation. +# +# Geometry: FNet3D's depth-4 encoder downsamples Z by 2**4 = 16, so the +# model input Z must be divisible by 16. The VSCyto3D stack center-crops to +# Z=15, which FNet3D cannot consume; we lift both the GPU center-crop and +# the CPU weighted crop to Z=32 (in_stack_depth stays 32, z_window stays +# 32 — the CPU crop takes the whole loaded z-slab, matching the VSCyto3D +# convention of cropping the full z on CPU and letting the GPU affine + +# center-crop do the yx work). Everything else (600 -> 384 weighted crop, +# num_samples=4, the affine + intensity augmentations) is verbatim from +# fcmae_vscyto3d_fit.yml. +# +# Structure-keyed like fnet3d_paper_fit.yml: single-set nucleus/membrane +# leaves list-replace normalizations + the CPU augmentation to re-key onto +# Nuclei/Membrane. Joint leaves author their own data: block inline. +# +# Paired with fnet3d_bigpatch_fit.yml (identical geometry + batch, flip-only +# augs) so Arm A (this overlay's sibling) and Arm B (this overlay) differ +# ONLY in the augmentation stack — a clean augmentation-effect comparison. +# +# batch_size is the on-GPU sample count for HCSDataModule (train_dataloader +# divides by RandWeightedCropd num_samples). At bf16-mixed (set in the leaf) +# a 384x384x32 patch halves the 32-true activation footprint, so batch_size +# is 8 (2 FOVs x num_samples=4); tuned from a single-GPU H200 smoke. +data: + init_args: + z_window_size: 32 + batch_size: 8 + num_workers: 4 + yx_patch_size: [384, 384] + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Structure] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + # CPU: 4 large weighted crops per FOV (VSCyto3D policy), z = full + # z_window so the GPU center-crop keeps all 32 planes. + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [32, 600, 600] + num_samples: 4 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [3.14, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[0.7, 1.3], [0.5, 1.5], [0.5, 1.5]] + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [32, 384, 384] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0.25, 0.75] + val_augmentations: + # CPU center-crop on the raw channel keys (the fnet3d_paper val + # mechanism), sized to the training patch. Validation applies no + # augmentation — only the deterministic center crop. + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Phase3D, Structure] + roi_size: [32, 384, 384] diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml new file mode 100644 index 000000000..205c531bb --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml @@ -0,0 +1,87 @@ +# pix2pix2d_unetvit fit-time HCS data hparams for the in-focus 2D benchmark +# track. Split out from model_overlays/pix2pix2d_unetvit_fit.yml so the +# model+trainer half there stays composable by joint-dataset +# (BatchedConcatDataModule) leaves that author their own data: block. +# +# Mirrors data_overlays/unetvit3d_fit.yml — which the 12 benchmarked +# pix2pix3d_unetvit leaves compose, and which is byte-identical to +# data_overlays/celldiff_fit.yml apart from one comment — flattened onto the +# offline `_focus.zarr` 5-plane in-focus slab stores, following exactly the +# convention already used by data_overlays/celldiff_2d_fit.yml and +# data_overlays/fcmae_vscyto2d_fit.yml: +# - z_window_size: 13 -> 1 +# - BatchedRandAffined rotate_range [3.14,0,0] -> [0,0,0] (rotation about +# axis 0 mixes Y and Z, which is degenerate at Z=1) +# - BatchedRandAffined scale_range Z [0.7,1.3] -> [1,1] (kornia affine +# scale is an absolute factor, so 1.0 is the no-op, not 0) +# - safe_crop_size / roi_size [8,512,512] -> [1,512,512] +# - BatchedRandGaussianSmoothd sigma_z [0.25,0.75] -> [0,0] +# XY augmentation policy (shear/scale/contrast/intensity/noise/smooth) is kept +# identical to the 3D overlay so 2D-vs-3D isolates geometry. +# +# batch_size stays 4 and the model overlay keeps the 4-GPU DDP topology, so the +# global batch is 4 x 4 = 16 samples/step, identical to the 3D arm. Holding it +# there is not cosmetic: DynacellGAN derives the G-EMA decay per-step from the +# global batch size, so a smaller batch would silently retune `ema_kimg` on top +# of changing steps/epoch. +# +# Measured on an A40 (44.7 GiB) at [1,512,512], bf16 autocast + two AdamW +# states, 3 alternating D/G steps: bs=4 -> 13.3 GiB (30%), bs=8 -> 25.0 GiB +# (56%), bs=16 -> OOM. So bs=4 has 3x headroom per rank on a 48 GB card, and +# consolidating the global batch onto one rank is not an option there. Raise +# batch_size only together with a >=80 GB constraint and a matching cut to +# trainer.devices, so the product stays 16. +data: + init_args: + z_window_size: 1 + batch_size: 4 + num_workers: 4 + yx_patch_size: [512, 512] + gpu_augmentations: + # GPU: affine on oversized patch → center crop to final 1×512×512. + # safe_crop_size clamps scale so the sheared/scaled source always + # covers the 512px crop, eliminating zero-corner artifacts. + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [0, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[1, 1], [0.5, 1.5], [0.5, 1.5]] + safe_crop_size: [1, 512, 512] + safe_crop_coverage: 0.9 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0, 0] + val_gpu_augmentations: + # The UNetViT generator requires exact input_spatial_size (fixed ViT + # positional embeddings). DivisibleCropd is insufficient — must + # center-crop to exactly the model input size. + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_4gpu_long.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_4gpu_long.yml new file mode 100644 index 000000000..029e9f327 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_4gpu_long.yml @@ -0,0 +1,52 @@ +# Hardware profile: 4 GPU DDP on H100/H200, A100 excluded, 7-day wall. +# +# Identical to hardware_4gpu.yml except for `time`. For fits whose 200-epoch +# budget does not fit in one 4-day allocation. +# +# Measured need (epochs/h from consecutive retained checkpoint mtimes within a +# single steady allocation -- not wall-time divided by step count): +# +# joint ER fcmae_vscyto3d_pretrained 1.82 ep/h -> 110 h to 200 ep (4.6 d) +# joint ER fcmae_vscyto3d_scratch 1.71 ep/h -> 117 h (4.9 d) +# joint mito fcmae_vscyto3d_scratch 1.65 ep/h -> 121 h (5.0 d) +# joint mito fcmae_vscyto3d_pretrained 1.58 ep/h -> 126 h (5.3 d) +# joint nucl fcmae_vscyto3d_pretrained 1.40 ep/h -> 143 h (6.0 d) +# joint memb fcmae_vscyto3d_scratch 1.25 ep/h -> 160 h (6.7 d) +# joint memb fcmae_vscyto3d_pretrained 1.24 ep/h -> 161 h (6.7 d) +# joint nucl fcmae_vscyto3d_scratch 1.22 ep/h -> 164 h (6.8 d) +# +# (The ER-pretrained rate reproduces across two independent intervals, +# e117->e150 and e130->e149, to three digits.) +# +# All eight joint FCMAE fits TIMEOUTed at the 4-day cap and were never resumed. +# The ER/mito four hit it **twice** each, leaving them at 150/200, 108/200, +# 81/200 and 70/200 epochs: jobs 31910331 + 34683420, 31910330 + 34694104, +# 31910343 + 34694106, 31910345 + 34683424. The nucleus/membrane four hit it once +# each, leaving 102/200, 86/200, 114/200 and 118/200: jobs 31822521 (nucl +# scratch), 33631899 (nucl pretrained, its third attempt after 31822355 +# CANCELLED and 31822498/33557666 FAILED), 31822536 (memb scratch), 31822529 +# (memb pretrained) -- every one TIMEOUT with elapsed 4-00:00:11 to 4-00:00:29 +# against a 4-00:00:00 limit. They are the only 4-GPU fits that have ever hit a +# wall limit -- every other leaf on hardware_4gpu.yml finishes inside 4 days, +# which is why this is a separate profile rather than a raise of the shared one. +# A 7-day 4-GPU H100/H200 allocation backfills far worse than a 4-day one, so do +# not move leaves here without measuring first. +# +# 7 days is 1.33x the slowest ER/mito requirement but only 1.02x the slowest +# nucleus one (164 h), so a nucleus/membrane fit started from epoch 0 would have +# ~4 h of margin. That is deliberate and safe here because these four are only +# ever **resumed**: from 102/86/114/118 epochs they need 80/81/69/66 h, i.e. 2.8 +# to 3.4 days. A from-scratch nucleus/membrane joint fit needs a longer wall than +# this profile provides -- size one from the rate above rather than assuming 7 +# days covers it. Joint fits are the slow case because they train on iPSC + A549 +# pooled, roughly doubling steps per epoch. +launcher: + sbatch: + partition: gpu + nodes: 1 + ntasks_per_node: 4 + cpus_per_task: 8 + gpus: 4 + mem: "512G" + constraint: "h100|h200" + time: "7-00:00:00" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml index 62406fee4..1c5c406f6 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml @@ -8,16 +8,38 @@ # used — A40 / A6000 / L40S / L4 all work and drain the queue faster than # pinning Hopper. # -# Hardware-shape constants (gpus, cpus_per_task, mem) match hardware_h200_single -# so resource accounting is identical; only the GPU vendor constraint is -# relaxed. +# Hardware-shape constants are sized from measurement, not copied from the fit +# profile. Across every COMPLETED predict in Slurm's retention window +# (2026-07-15 onward, ~1500 jobs over 46 job-name families) the peak RSS of any +# family was 3.58 GiB and every family but one sat at or below 2.75 GiB, against +# the 256G that used to be requested here. Peak CPU was 13.6 cores +# (TotalCPU/Elapsed, fnet2d job 35038580: 6030 s / 443 s); family medians run +# 1.0-4.1 cores, and every predict leaf in the tree composes `num_workers: 0`, +# so dataloading is in-process by construction. +# +# 16 cores clears the observed maximum and 64G is ~18x the observed peak RSS. +# The old 256G was the binding constraint on throughput, not the GPU: it caps a +# 500G node at 2 concurrent predicts, so a 4-GPU node would strand two of its +# GPUs. Same reasoning as hardware_predict_celldiff_lite.yml. +# +# This deliberately NO LONGER matches hardware_h200_single. That profile is +# shared with 48 fit leaves, so it must not be re-tuned from predict data; +# its predict leaves moved to hardware_predict_h200.yml for the same reason. +# +# `time` is sized from measurement, not habit: across every completed predict in +# Slurm's retention window the longest single-pass run was 21.9 h (a pix2pix3d +# sliding-window predict on an A6000), so 2 days is ~2.2x the observed maximum. +# CELL-Diff is the one family that does not fit under this cap and has its own +# profile -- see hardware_predict_celldiff.yml. Do NOT raise this back to 4 days +# to accommodate a slow leaf; give that leaf a profile, or the cap stops meaning +# anything. launcher: sbatch: partition: gpu nodes: 1 ntasks_per_node: 1 - cpus_per_task: 32 + cpus_per_task: 16 gpus: 1 - mem: "256G" + mem: "64G" constraint: null - time: "4-00:00:00" + time: "2-00:00:00" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml new file mode 100644 index 000000000..a5bd04a01 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml @@ -0,0 +1,32 @@ +# Hardware profile: single GPU, no vendor constraint, for CELL-Diff predict. +# Pair with recipes/topology/single_gpu.yml. +# +# Identical to hardware_predict_any_gpu.yml except for `time`, including its +# measured 16-core / 64G shape -- the CELL-Diff predict families top out at +# 2.57 GiB RSS and 1.58 cores, so they are the least demanding of all, and the +# wall time is the only thing that sets them apart. CELL-Diff is +# iterative-diffusion inference, so it costs one to two orders of magnitude more +# wall time per volume than the single-pass regressors and even than the +# pix2pix3d GAN: measured 5.8-95.6 h for a completed A549-target predict, versus +# a 21.9 h maximum across every other family. +# +# 95.6 h against the old shared 4-day (96 h) cap was not headroom, it was a +# coin flip. Eight CELL-Diff predicts hit TIMEOUT at exactly 4-00:00:xx on +# 2026-07-19 (job ids 34880975/34880977/34880978, 34881099, 34881103/34881104/ +# 34881105, 34881175 -- SEC61B, TOMM20 and NUCL), each losing four days of GPU +# and leaving a partial prediction.zarr behind. +# +# 7 days is ~1.75x the longest run that has ever completed. Over-provisioning +# here only costs backfill priority (the gpu partition's MaxTime is 180 days), +# whereas under-provisioning costs four days plus a re-predict. Hangs are no +# longer this limit's job to catch -- see tools/watch_stalled_jobs.py. +launcher: + sbatch: + partition: gpu + nodes: 1 + ntasks_per_node: 1 + cpus_per_task: 16 + gpus: 1 + mem: "64G" + constraint: null + time: "7-00:00:00" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml new file mode 100644 index 000000000..906868ca4 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml @@ -0,0 +1,20 @@ +# Hardware profile: one H100 for a CELL-Diff predict on the DynaCell-lite test set +# with the fast recipe (model_overlays/celldiff_predict_lite.yml). +# +# Sized from measurement (experiments/2026-10-01_celldiff-fast-inference): one lite +# condition takes 5-35 min on an H100 (A549 conditions are the long ones). 2 h is +# >3x that; production CELL-Diff predicts keep hardware_predict_celldiff.yml. +# Peak RSS was 5.3-6.2 GB, so 32G is ample; larger requests miss H100 nodes whose +# memory is otherwise allocated. +# Pinned to H100 because the 2 h per-fit target is an H100 number; other GPUs run it +# correctly, just slower. +launcher: + sbatch: + partition: gpu + nodes: 1 + ntasks_per_node: 1 + cpus_per_task: 16 + gpus: 1 + mem: "32G" + constraint: "h100" + time: "02:00:00" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_predict_h200.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_predict_h200.yml new file mode 100644 index 000000000..1fe80f336 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/launcher_profiles/hardware_predict_h200.yml @@ -0,0 +1,42 @@ +# Hardware profile: one H200, for predict mode on the VSCyto3D-pretrained family. +# Pair with recipes/topology/single_gpu.yml. +# +# Exists to decouple these predicts from hardware_h200_single.yml, which 48 FIT +# leaves also compose (44 train.yml + 4 train_smoke.yml) and which therefore +# cannot be re-tuned from predict data. Before this profile the 41 predict leaves +# on it inherited the fit shape of 32 cores and 256G. +# +# Sized from measurement. Across every COMPLETED predict of these leaves that +# sacct still retains (19 jobs, all fcmae_vscyto3d_pretrained): peak RSS was +# 2.02 GiB and peak CPU was 2.92 cores (TotalCPU/Elapsed, job 34880997 = +# 4628 s / 1586 s), with a median of 2.41 cores. These compose +# `num_workers: 0` and `batch_size: 1`, so dataloading is in-process and cannot +# use more. 16 cores and 64G match the other predict profiles and leave ~5x and +# ~30x headroom over those peaks. +# +# `constraint: h200` is DELIBERATELY KEPT, and is not a measured requirement -- +# predict is `full_image` at 512x512x15 and fp32, which fits comfortably on +# smaller cards, and a sibling leaf of this same model dir +# (_dual_nucl_memb/.../predict__hek_mantis_kras_a549xy.yml, constraint +# a40|l40s|a6000|a100|h100|h200) COMPLETED on gpu-f-5. The pin stays because GPU +# type perturbs outputs in this tree -- cross-GPU segmentation mask floors and +# reduction-order PCC differences are both documented -- so unpinning risks +# moving published numbers on a re-predict. Relaxing it is a defensible separate +# decision, not a side effect of fixing the CPU and memory request. +# +# `time` stays at the 4 days these leaves already had. 16 of the 41 leaves +# (vscyto3d_cytolandft, vscyto3d_infectionft_dynacellft) still compose +# `ckpt_path: REPLACE_ME_WITH_PRODUCTION_CHECKPOINT_PATH` and have never +# completed a run, so their wall need is unmeasured; an unmeasured family +# inherits a conservative cap rather than a speculative one. The 25 that do run +# top out at 0.65 h. Tighten this once the other 16 produce a number. +launcher: + sbatch: + partition: gpu + nodes: 1 + ntasks_per_node: 1 + cpus_per_task: 16 + gpus: 1 + mem: "64G" + constraint: "h200" + time: "4-00:00:00" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/celldiff_2d_fit.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/celldiff_2d_fit.yml new file mode 100644 index 000000000..da9210c63 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/celldiff_2d_fit.yml @@ -0,0 +1,65 @@ +# CellDiff-2D fit overlay — model + trainer only — for the in-focus 2D +# benchmark track. HCS data hparams live in +# data_overlays/celldiff_2d_fit.yml; single-store train leaves compose +# both, joint (BatchedConcatDataModule) leaves compose only this one and +# author data: themselves. +# +# Mirrors model_overlays/celldiff_fit.yml but binds the celldiff_fm_2d +# recipe (input_spatial_size [1,512,512], patch_size [1,4,4]). CellDiff was +# already single-GPU, so topology is unchanged. lr / schedule / transport / +# num_log_steps all match the 3D CellDiff baseline so the 2D-vs-3D +# comparison isolates geometry. +# +# warmup_steps: 8500 is inherited from the 3D overlay deliberately — +# steps/epoch differ at z_window_size=1, so this is a fraction-of-run knob +# that was tuned for the 3D leaf, not a "~1 epoch" target. Same open +# question flagged in model_overlays/fcmae_vscyto2d_fit.yml; left aligned +# with 3D rather than silently re-tuned. +base: + - ../../../../../../recipes/models/celldiff_fm_2d.yml + - ../../../../../../recipes/trainer/fit.yml + - ../../../../../../recipes/topology/single_gpu.yml +seed_everything: 0 +model: + init_args: + net_config: + input_spatial_size: [1, 512, 512] + lr: 0.0003 + schedule: WarmupCosine + warmup_steps: 8500 + warmup_multiplier: 1e-3 + num_log_steps: 10 + # Log flow-matching validation loss. The engine defaults this off + # (engine.py:832) and without it CellDiff logs NO validation metric at + # all, so `save_top_k: -1` keeps all 20 epochs, there is no best-by-monitor + # checkpoint, and the arm cannot be checked for convergence — measured + # 2026-09-09 against the archived pre-fix runs, where every other 2D + # family had a `loss/validate` curve and this one had nothing. + # + # Cheap, despite CellDiff inference being slow: `validation_step` calls + # `self.model(phase, target)`, the same single velocity-field prediction at + # one sampled timestep as `training_step`. It does NOT integrate the ODE — + # that is `generate()` at `num_generate_steps: 100`, predict-mode only. + # At `split_ratio: 0.8` and no backward pass this is ~8% of epoch time. + # + # ⚠ The metric is noisy: `t` is resampled per example, so a 20-point curve + # has high epoch-to-epoch variance. Pin the validation timestep grid before + # reading it as a saturation monitor, not just as a logged number. + # + # 2D only, on request. `model_overlays/celldiff_fit.yml` (3D) is still off, + # so convergence is NOT yet comparable across the 2D/3D CellDiff pair. + # + # ⚠ PROVENANCE: the canonical post-affine-fix CellDiff-2D fits on disk + # (2026-09-09, 12/12 COMPLETED 0:0) PREDATE this flag and therefore carry + # NO `loss/validate` curve. A rerun to add one was launched and then + # deliberately cancelled — the existing fits are scientifically valid and + # re-spending ~15 GPU-h for a monitoring metric was judged not worth it. + # This flag applies to the NEXT CellDiff-2D fit, not to those weights. + compute_validation_loss: true +trainer: + # bf16-mixed, matching the 3D CellDiff overlay. No GradScaler, so a NaN + # gradient surfaces as a non-finite loss instead of a silently skipped + # step — the failure mode that froze the first 24 FCMAE-2D fits at + # initialization. Do NOT switch to 16-mixed. + precision: bf16-mixed + max_epochs: 20 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/celldiff_2d_predict.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/celldiff_2d_predict.yml new file mode 100644 index 000000000..1298020d9 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/celldiff_2d_predict.yml @@ -0,0 +1,35 @@ +# CellDiff-2D predict overlay for the in-focus 2D benchmark track. Binds the +# celldiff_fm_2d model recipe + predict trainer recipe, then layers predict-time +# model hparams and data-loader settings. Predict-time normalizations and +# data_path are leaf-owned (leaf overrides target-inherited values to match each +# organelle's test store). +# +# CRITICAL: predict rebuilds the model from the celldiff_fm_2d recipe's +# net_config (input_spatial_size [1,512,512], patch_size [1,4,4]) and then loads +# the trained weights; data.z_window_size MUST be 1 so the datamodule emits one +# window per z-plane of the full-Z 3D test store, matching the Z-preserving 2D +# checkpoint. A z_window_size mismatch would feed a multi-plane window into a +# Z=1 network and error. Same contract as fnet2d_predict.yml. +# +# predict_overlap Z is 0, NOT the 3D overlay's 4: `window_starts` requires +# 0 <= overlap < patch on every axis, and the Z patch is 1 here, so any non-zero +# Z overlap raises. XY overlap stays 256 — `iterative` anchors overlapping tiles +# via velocity, which is what keeps tile seams out of the 640x960 A549 stores +# (the same lattice/seam problem the pix2pix3d de-latticing fixed). +base: + - ../../../../../../recipes/models/celldiff_fm_2d.yml + - ../../../../../../recipes/trainer/predict.yml + - ../../../../../../recipes/topology/single_gpu.yml +model: + init_args: + net_config: + input_spatial_size: [1, 512, 512] + num_generate_steps: 100 + predict_method: iterative + predict_overlap: [0, 256, 256] +data: + init_args: + z_window_size: 1 + batch_size: 1 + num_workers: 0 + yx_patch_size: [512, 512] diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/celldiff_predict_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/celldiff_predict_lite.yml new file mode 100644 index 000000000..f1245160c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/celldiff_predict_lite.yml @@ -0,0 +1,40 @@ +# CellDiff fast predict overlay for the DynaCell-lite test set. +# Same model and the same tile grid as celldiff_predict.yml (512^2 tiles, YX overlap 256, +# iterative anchoring); only the Z overlap, the sampler, the precision and cudnn.benchmark change. Chosen and +# validated in applications/dynacell/experiments/2026-10-01_celldiff-fast-inference/ (1.43 h per fit +# for the whole lite test set on one H100; with an organelle's three fits replaced, 8 of 7984 resolvable +# pairs against other models flip and 3 of 447 among the CELL-Diff fits, and the lite resolves 2 of them +# the other way, both marginal on the full benchmark -- see "DynaCell-lite" in applications/dynacell/CLAUDE.md): +# - Z overlap 2 instead of 4 (8 instead of 11 Z tiles per A549 volume); +# - sampler: midpoint on the Beta(0.4, 0.3) quantiles of 8 uniform points, 14 velocity evaluations +# per tile, instead of adaptive dopri5 (~56-66). The grid is packed toward the data end (last +# step 0.006): grids with a coarse last step lose the fine texture the deep features read +# (Beta(0.5, 0.7), last step 0.13, shifted A549 DynaCLR KID by ~20 between-FOV SD), and the +# cosine grid needs 16 evaluations (12 flip the A549-trained nucleus fit); +# - bf16 autocast + torch.compile of a channels-last copy of the net. +# - cudnn.benchmark (trainer.benchmark): -6.7 % end to end on H100; it moves pixels by relL2 0.0016, +# 20x below the GPU-model drift the orderings were checked across. +# Larger tiles (full-field slabs, whole volumes) were tested and fail on A549 out of domain. +base: + - ../../../../../../recipes/models/celldiff_fm.yml + - ../../../../../../recipes/trainer/predict.yml + - ../../../../../../recipes/topology/single_gpu.yml +model: + init_args: + net_config: + input_spatial_size: [8, 512, 512] + predict_method: iterative + predict_overlap: [2, 256, 256] + predict_sampling_method: midpoint + predict_time_schedule: [0.4, 0.3] + num_generate_steps: 8 + predict_compile: true +trainer: + precision: bf16-mixed + benchmark: true +data: + init_args: + z_window_size: 40 + batch_size: 4 + num_workers: 0 + yx_patch_size: [512, 512] diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml new file mode 100644 index 000000000..3d5875adb --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml @@ -0,0 +1,68 @@ +# Shared FCMAE-2D (FullyConvolutionalMAE, pretraining=False) fit overlay +# for the in-focus 2D benchmark track. Geometry is the published VSCyto2D +# recipe (applications/cytoland/examples/configs/recipes/models/fcmae_2d.yml, +# plan M5): in_stack_depth=1, stem_kernel_size=[1,2,2]. Used by both +# fcmae_vscyto2d_scratch and fcmae_vscyto2d_pretrained leaves — +# encoder_only + ckpt_path are set only in the pretrained leaf so init is +# the only difference between the two (lr drops to 0.0002 there, +# mirroring cytoland vscyto2d finetuning). +# +# Mirrors model_overlays/fcmae_vscyto3d_fit.yml but with 2D geometry and +# single-GPU topology: +# - stem_kernel_size [5,4,4] -> [1,2,2], in_stack_depth 15 -> 1 +# - topology ddp_4gpu -> single_gpu (2D nets are light; a Phase-B +# throughput decision — see plan §2d). No explicit DDPStrategy / +# find_unused_parameters / 3h-timeout block is needed at single-device +# (SingleDeviceStrategy has no DDP reducer, so FCMAE pretraining=False +# unused decoder/head paths are fine). If a later throughput probe +# switches this to DDP, re-add the fcmae_vscyto3d_fit.yml +# DDPStrategy(find_unused_parameters=true, timeout="3:00:00") block. +# +# HCS data hparams (bs=16, z=1, yx=384, flattened augs) live in +# data_overlays/fcmae_vscyto2d_fit.yml; single-store train leaves compose +# both, joint (BatchedConcatDataModule) leaves compose only this one and +# author data: themselves. +base: + - ../../../../../../recipes/trainer/fit.yml + - ../../../../../../recipes/topology/single_gpu.yml +model: + class_path: dynacell.engine.DynacellUNet + init_args: + architecture: fcmae + model_config: + in_channels: 1 + out_channels: 1 + encoder_blocks: [3, 3, 9, 3] + encoder_drop_path_rate: 0.1 + dims: [96, 192, 384, 768] + decoder_conv_blocks: 2 + stem_kernel_size: [1, 2, 2] + in_stack_depth: 1 + pretraining: false + loss_function: + class_path: viscy_utils.losses.MixedLoss + init_args: + l1_alpha: 0.5 + l2_alpha: 0.0 + ms_dssim_alpha: 0.5 + lr: 0.0004 + schedule: WarmupCosine + # Phase-B TODO: re-size warmup_steps to ~1 epoch once the focus-store + # FOV count is known (single-GPU bs=16 at z_window_size=1 emits ~5 + # windows/FOV/T, so steps/epoch differ from the 3D 4-GPU baseline). + warmup_steps: 4000 + warmup_multiplier: 1e-3 +trainer: + # bf16, NOT fp16, and deliberately different from the 3D FCMAE overlay. + # fp16-mixed installs a GradScaler, which converts a NaN *gradient* into a + # silently skipped optimizer step: the forward and the logged loss stay finite + # while the scale halves, and once it reaches 0.0 every step is skipped for the + # rest of the run. That is exactly how the first 24 FCMAE-2D fits reached + # `epoch 199/200` with their weights still at initialization and `COMPLETED 0:0`. + # bf16 has no scaler and needs none (same ~8-bit exponent range as fp32), so a + # NaN gradient shows up as a non-finite loss instead of as silence. + # `OptimizerHealthCheck` (injected into every fit by viscy_utils.cli) catches + # both shapes; this makes the loud one the default. Depth=1 is the regime where + # the bf16 SSIM variance cancellation bites, so do NOT revert to 16-mixed. + precision: bf16-mixed + max_epochs: 200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml new file mode 100644 index 000000000..53ff3f1ca --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml @@ -0,0 +1,49 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) predict overlay for +# the in-focus 2D benchmark track. Mirrors fcmae_vscyto3d_predict.yml but +# with 2D geometry. +# +# CRITICAL: predict rebuilds the model from THIS overlay's model_config +# and then loads the trained weights (engine.py:308), so the full 2D +# model_config MUST be re-declared here (in_stack_depth=1, +# stem_kernel_size=[1,2,2]) and data.z_window_size MUST be 1 — otherwise +# load_state_dict fails on a stem/conv shape mismatch against the 2D +# checkpoint. Used by both fcmae_vscyto2d_pretrained and +# fcmae_vscyto2d_scratch predict leaves — predict loads the full trained +# checkpoint, so the pretrained-encoder warm-start path (encoder_only + +# ckpt_path) from the fit leaf does NOT belong here. +# +# The 2D model predicts each z-plane of the full-Z 3D test store from its +# own phase plane (z_window_size=1 -> one window per z; the writer keys +# each output to its z-index, z_padding=0). 640x960 / 512x512 need no YX +# pad (num_blocks=4 -> multiple of 16). +base: + - ../../../../../../recipes/trainer/predict.yml + - ../../../../../../recipes/topology/single_gpu.yml +model: + class_path: dynacell.engine.DynacellUNet + init_args: + architecture: fcmae + model_config: + in_channels: 1 + out_channels: 1 + encoder_blocks: [3, 3, 9, 3] + encoder_drop_path_rate: 0.1 + dims: [96, 192, 384, 768] + decoder_conv_blocks: 2 + stem_kernel_size: [1, 2, 2] + in_stack_depth: 1 + pretraining: false + loss_function: + class_path: viscy_utils.losses.MixedLoss + init_args: + l1_alpha: 0.5 + l2_alpha: 0.0 + ms_dssim_alpha: 0.5 + predict_method: full_image + predict_overlap: [4, 256, 256] +data: + init_args: + z_window_size: 1 + batch_size: 1 + num_workers: 0 + yx_patch_size: [512, 512] diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_fit.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_fit.yml index 26a48d76f..a19d0d55d 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_fit.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fcmae_vscyto3d_2chan_fit.yml @@ -37,3 +37,4 @@ trainer: strategy: ddp_find_unused_parameters_true precision: 16-mixed max_epochs: 200 + benchmark: true # see fcmae_vscyto3d_fit.yml diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fcmae_vscyto3d_fit.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fcmae_vscyto3d_fit.yml index 6148672f8..e4e27b105 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fcmae_vscyto3d_fit.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fcmae_vscyto3d_fit.yml @@ -39,9 +39,25 @@ trainer: # only receive gradients on some forward paths; default ddp with # find_unused_parameters=False errors at step 1. Matches the canonical # vs_test/finetune_3d.py:215 recipe. - strategy: ddp_find_unused_parameters_true + # + # Explicit DDPStrategy with a 3 h process-group timeout (default is 30 min): + # on a contended shared FS, epoch-boundary checkpoint writes (386 MB/ckpt x + # many concurrent DDP jobs) can stall one rank past 30 min, tripping the NCCL + # watchdog on the tiny epoch-end metric ALLREDUCE and aborting the run + # (observed on 34683418/34683421). A longer timeout tolerates transient I/O + # stalls while still failing a genuinely hung rank. + strategy: + class_path: lightning.pytorch.strategies.DDPStrategy + init_args: + find_unused_parameters: true + timeout: "3:00:00" # h:m:s (jsonargparse parses timedelta from this string form) precision: 16-mixed max_epochs: 200 + # cudnn.benchmark: 0.900 vs 4.322 s/step on one H200; train-loss gap 1.25x the replicate + # floor over 400 warm-up steps, one pair (weak; speedup RECOMMENDATIONS.md s7). + # No compile_model: slower under DDP. + # Fit-only by decision: predicts keep the defaults their stores were made with. + benchmark: true # HCS data hparams (bs=32, z=20, yx=384, augs) live in # data_overlays/fcmae_vscyto3d_fit.yml; single-store train leaves compose # both, joint (BatchedConcatDataModule) leaves compose only this one and diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fnet2d_fit.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fnet2d_fit.yml new file mode 100644 index 000000000..8673d672d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fnet2d_fit.yml @@ -0,0 +1,25 @@ +# FNet2D fit overlay — model + trainer only — for the in-focus 2D +# benchmark track. HCS data hparams (the mean/std Structure normalization +# and 8-crops-per-FOV sampling that diverge from the CellDiff/UNetViT +# conventions) live in data_overlays/fnet2d_fit.yml; single-store train +# leaves compose both, joint (BatchedConcatDataModule) leaves compose only +# this one and author data: themselves. +# +# Mirrors model_overlays/fnet3d_paper_fit.yml but binds the fnet2d model +# recipe (in_stack_depth=1, downsample_z=false). FNet3D was already +# single-GPU, so topology is unchanged. lr/schedule/loss/precision/ +# max_steps all match the 3D FNet paper baseline. +base: + - ../../../../../../recipes/models/fnet2d.yml + - ../../../../../../recipes/trainer/fit.yml + - ../../../../../../recipes/topology/single_gpu.yml +seed_everything: 0 +model: + init_args: + loss_function: + class_path: torch.nn.MSELoss + lr: 0.001 + schedule: Constant +trainer: + precision: 32-true + max_steps: 200000 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fnet2d_predict.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fnet2d_predict.yml new file mode 100644 index 000000000..a63c1831a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fnet2d_predict.yml @@ -0,0 +1,26 @@ +# FNet2D predict overlay for the in-focus 2D benchmark track. Binds the +# fnet2d model recipe + predict trainer recipe, then layers predict-time +# model hparams and data-loader settings. Predict-time normalizations and +# data_path are leaf-owned (leaf overrides target-inherited values to +# match each organelle's test_cropped store). +# +# CRITICAL: predict rebuilds the model from the fnet2d recipe's +# model_config (in_stack_depth=1, downsample_z=false) and then loads the +# trained weights (engine.py:308); data.z_window_size MUST be 1 so the +# datamodule emits one window per z-plane of the full-Z 3D test store, +# matching the Z-preserving 2D checkpoint. A z_window_size mismatch would +# feed a multi-plane window into a Z=1 network and error. +base: + - ../../../../../../recipes/models/fnet2d.yml + - ../../../../../../recipes/trainer/predict.yml + - ../../../../../../recipes/topology/single_gpu.yml +model: + init_args: + predict_method: full_image + predict_overlap: [4, 256, 256] +data: + init_args: + z_window_size: 1 + batch_size: 1 + num_workers: 0 + yx_patch_size: [512, 512] diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fnet3d_paper_fit.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fnet3d_paper_fit.yml index b475307a2..709fef265 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fnet3d_paper_fit.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/fnet3d_paper_fit.yml @@ -19,6 +19,11 @@ model: class_path: torch.nn.MSELoss lr: 0.001 schedule: Constant + channels_last: true trainer: precision: 32-true max_steps: 200000 + # cudnn.benchmark + channels_last (not saved in hparams): 0.493 vs 0.918 s/step on one + # H200, loss within the replicate floor (2026-10-11, speedup RECOMMENDATIONS.md s7). + # Fit-only by decision: predicts keep the defaults their stores were made with. + benchmark: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml new file mode 100644 index 000000000..f43dd4199 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml @@ -0,0 +1,92 @@ +# pix2pix2d_unetvit fit overlay — model + trainer only — for the in-focus 2D +# benchmark track. HCS data hparams live in +# data_overlays/pix2pix2d_unetvit_fit.yml; single-store train leaves compose +# both, joint (BatchedConcatDataModule) leaves compose only this one and +# author data: themselves. +# +# Binds the pix2pix2d_unetvit recipe (generator input_spatial_size +# [1,512,512] + patch_size [1,4,4], discriminator preserve_z: true) and +# mirrors the "Run D" recipe that actually produced the published +# pix2pix3d_unetvit rows, so 2D-vs-3D isolates geometry. +# +# ⚠ Run D, NOT the LSGAN baseline in pix2pix3d_unetvit_fit.yml. That file is +# what the stale `train.yml` leaves compose, but it is NOT what trained the +# benchmarked weights: the 12 `train_4gpu_modernized.yml` leaves are, and the +# checkpoints prove it. Read out of +# a549/nucleus/pix2pix3d_unetvit/checkpoints/epoch=39-step=86400.ckpt +# `hyper_parameters` (same on ipsc and joint): +# loss_type='nonsat' lr_g=2e-4 lr_d=2e-4 r1_gamma=10.0 +# ema_kimg=10.0 lecam_gamma=0.3 lambda_l1=10.0 +# use_ema_at_predict=True + 201 generator_ema.* tensors, epoch=39 +# Mirroring the LSGAN overlay instead would have pitted a 2D LSGAN arm against +# a 3D Run-D arm and confounded geometry with the training recipe. Check the +# checkpoint's own hparams before assuming a leaf's overlay is what ran. +# +# The three Run-D deltas over the modernized overlay (lambda_l1: 10.0, +# lecam_gamma: 0.3, max_epochs: 40) are baked here rather than left to each +# leaf, unlike the 3D leaves which repeat them 12 times. +# +# warmup_steps: 8500 is inherited from the 3D overlay deliberately — steps per +# epoch differ at z_window_size=1, so this is a fraction-of-run knob tuned for +# the 3D leaf, not a "~1 epoch" target. Same open question flagged in +# model_overlays/celldiff_2d_fit.yml and fcmae_vscyto2d_fit.yml; left aligned +# with 3D rather than silently re-tuned. +# +# TOPOLOGY: 4-GPU DDP, same as 3D, because the global batch has to be held at +# 16 samples/step. The 3D arm ran 4 ranks x batch_size 4; a GAN cannot absorb a +# batch change quietly, since DynacellGAN derives the G-EMA decay per-step from +# the global batch size, so halving it would silently retune `ema_kimg` as well +# as steps/epoch. Collapsing to one rank was measured and rejected: on an A40 +# (44.7 GiB) at [1,512,512] with bf16 autocast + two AdamW states, peak is +# 13.3 GiB at bs=4 (30%) and 25.0 GiB at bs=8 (56%), and bs=16 **OOMs**. So a +# single rank cannot carry the 3D global batch on a 48 GB card; 4 x bs=4 can, +# with 3x headroom per rank. +# +# `ddp_4gpu_gan.yml` (not `ddp_4gpu.yml`) is required: manual optimization +# toggles requires_grad per sub-step, so DDP needs find_unused_parameters=True. +# Confirmed separately that `bottleneck.img_pos_embed` receives no gradient — +# in the 3D generator too, so it is pre-existing, not a 2D artifact, and it is +# a second reason the GAN topology is the right one here. +# +# Leaves override the hardware profile's `constraint: h100|h200` down to the +# 48 GB cards. That profile reserves Hopper for FCMAE/UNeXt2 ranks needing +# 30-50 GB; 13.3 GiB per rank does not qualify, and the profile documents the +# opt-out explicitly. Leaves also cut `mem: 512G` to 128G — the focus stores are +# 5-plane, so the 512G ceiling is inherited 3D scale. Both go in the LEAF BODY, +# never here: launcher_profiles compose *after* model overlays and would win. +# +# bf16-mixed carries no GradScaler, so a NaN gradient surfaces as a +# non-finite loss instead of a silently skipped step — the failure mode that +# froze the first 24 FCMAE-2D fits at initialization. Do NOT switch to +# 16-mixed. +# +# seed_everything is deliberately left at the trainer recipe's 42, which is +# what the 3D pix2pix leaves also inherit. fnet2d_fit.yml and +# celldiff_2d_fit.yml pin 0 while their 3D counterparts inherit 42 — an +# existing inconsistency in the 2D track. Matching this family's own 3D arm +# matters more here, because the comparison being drawn is pix2pix2d vs +# pix2pix3d. +base: + - ../../../../../../recipes/models/pix2pix2d_unetvit.yml + - ../../../../../../recipes/trainer/fit.yml + - ../../../../../../recipes/topology/ddp_4gpu_gan.yml +model: + init_args: + loss_type: nonsat + lambda_adv: 1.0 + r1_gamma: 10.0 + r2_gamma: 0.0 + r1_every: 16 + ema_kimg: 10.0 + lecam_gamma: 0.3 + lecam_decay: 0.9 + lambda_l1: 10.0 + use_ema_at_predict: true + lr_g: 2.0e-4 + lr_d: 2.0e-4 + schedule: WarmupCosine + warmup_steps: 8500 + warmup_multiplier: 1e-3 +trainer: + precision: bf16-mixed + max_epochs: 40 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml new file mode 100644 index 000000000..3a82ab419 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml @@ -0,0 +1,66 @@ +# pix2pix2d_unetvit predict overlay for the in-focus 2D benchmark track. Binds +# the pix2pix2d_unetvit model recipe + predict trainer recipe, then layers +# predict-time model hparams and data-loader settings. Predict-time +# normalizations and data_path are leaf-owned (leaf overrides target-inherited +# values to match each organelle's test store). +# +# CRITICAL: predict rebuilds the model from the pix2pix2d_unetvit recipe +# (generator input_spatial_size [1,512,512], patch_size [1,4,4], discriminator +# preserve_z: true) and then loads the trained weights; data.z_window_size MUST +# be 1 so the datamodule emits one window per z-plane of the full-Z 3D test +# store, matching the Z-preserving 2D checkpoint. A z_window_size mismatch +# would feed a multi-plane window into a Z=1 network and error. Same contract +# as fnet2d_predict.yml and celldiff_2d_predict.yml. The discriminator is not +# exposed at inference — DynacellGAN.predict_step uses the generator only — +# but it is still constructed, so preserve_z has to stay consistent with the +# checkpoint or the state_dict load would mismatch on the D weights. +# +# predict_overlap Z is 0, NOT the 3D overlay's 4: `window_starts` requires +# 0 <= overlap < patch on every axis, and the Z patch is 1 here, so any +# non-zero Z overlap raises. Same correction celldiff_2d_predict.yml carries. +# +# sliding_window is still required at Z=1. The reason is lateral, not axial: +# the ViT generator is fixed at 512x512 by its positional embeddings, and the +# A549 test set is 640x960 (the iPSC test is a single 512x512 tile). +base: + - ../../../../../../recipes/models/pix2pix2d_unetvit.yml + - ../../../../../../recipes/trainer/predict.yml + - ../../../../../../recipes/topology/single_gpu.yml +model: + init_args: + # The fit overlay mirrors Run D, which sets ema_kimg: 10.0, so every + # checkpoint carries 201 generator_ema.* tensors and picked its best epoch + # on loss/validate_ema. Those EMA weights are what the recipe selected on, + # so they are what the benchmark must report. + # + # ema_kimg is deliberately NOT restated here. DynacellGAN used to build the + # EMA shadow only when ema_kimg was set, so a predict overlay that omitted + # it made strict=False silently drop all 201 tensors and inference fell + # back to the raw generator — 149 pix2pix3d predict runs logged exactly + # that, and every Pix2Pix3D number published before 2026-07-30 was produced + # that way. engine.py now builds the shadow from the checkpoint's own + # generator_ema.* keys, so ema_kimg is a training constant and restating it + # in predict configs is what let the drop go unnoticed. Do not add it back. + # + # use_ema_at_predict stays explicit because engine.py deliberately does NOT + # adopt it from the checkpoint. + use_ema_at_predict: true + predict_method: sliding_window + predict_overlap: [0, 256, 256] + # Shift averaging suppresses the two lattices the cosine blend does not + # touch: the decoder's ConvTranspose checkerboard (2/4/8 px) and the ViT + # bottleneck's token grid (32 px). Both are in-plane, so they are present at + # Z=1 for exactly the same reasons as in 3D — the generator's decoder and + # bottleneck are unchanged apart from the Z patch extent. Carried over + # verbatim from pix2pix3d_unetvit_predict.yml, including the (dy, dx) PAIR + # form: a flat [0, 5, 11, 22] is expanded to its outer product and costs 16 + # tiled passes instead of 4 for the same result. Do NOT swap in offsets that + # merely zero the period-32 phasor — those are congruent mod 8 and reinstate + # the short periods, measuring two to three times worse. + predict_phase_shifts: [[0, 0], [5, 11], [11, 22], [22, 5]] +data: + init_args: + z_window_size: 1 + batch_size: 1 + num_workers: 0 + yx_patch_size: [512, 512] diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/pix2pix3d_unetvit_predict.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/pix2pix3d_unetvit_predict.yml index 0c365440e..7e066e3ba 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/pix2pix3d_unetvit_predict.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/pix2pix3d_unetvit_predict.yml @@ -11,8 +11,71 @@ base: - ../../../../../../recipes/topology/single_gpu.yml model: init_args: - predict_method: full_image + # Every modernized (Run-D) checkpoint carries 201 generator_ema.* tensors and + # picked its best epoch on loss/validate_ema. DynacellGAN used to build the EMA + # shadow only when ema_kimg was set, so an overlay that omitted it made + # strict=False drop all 201 at load and inference fell back to the raw + # generator -- 149 predict runs logged exactly that: + # DynacellGAN predict: using raw generator + # (ema_kimg=None, use_ema_at_predict=True, generator_ema=absent) + # Every Pix2Pix3D number published before 2026-07-30 was produced that way. + # engine.py now builds the shadow from the checkpoint's own generator_ema.* + # keys, so ema_kimg is no longer needed here -- it is a training constant, and + # restating it in predict configs is what let the drop go unnoticed. + # + # use_ema_at_predict stays explicit (engine.py deliberately does NOT adopt it + # from the checkpoint) and is now true: the EMA weights are the ones the + # recipe selected checkpoints on, so they are what the benchmark should + # report. This is the campaign flip -- it changes every Pix2Pix3D number, and + # is paired with a full re-predict + re-eval, not a config-only edit. The raw + # arm's metrics are preserved in the B0 CSV snapshot and in git. + # + # Size of the flip, measured before the campaign was authorized (5 paired + # iPSC ER FOVs, ckpt epoch=37-step=102752, same sliding-window predict path, + # differing only in use_ema_at_predict): + # + # image space rel L2(ema, raw) 0.143 .. 0.185, mean 0.166 + # PCC(ema, raw) 0.981 .. 0.989 + # metric space PCC +0.0119 Spectral_PCC +0.0090 + # SSIM -0.0038 NRMSE +0.0046 + # PSNR -0.4899 + # scale-inv si-SSIM +0.0112 si-PSNR +0.1916 + # si-NRMSE -0.0011 + # + # Two things to read from that. The weight-space gap alone (relative L2 + # 0.0017) badly understates the effect -- in image space it is ~100x larger, + # and the difference is smooth and structure-correlated, not noise. And under + # the old min-max formulation the raw generator looked BETTER on SSIM, NRMSE + # and PSNR, which is how 149 runs went unnoticed: the dropped-EMA defect and + # the metric formulation partially cancelled. Only PCC, which is invariant to + # both, moves the same way in both formulations. + use_ema_at_predict: true + # ViT generator is fixed at 512x512; the A549 test set is 640x960, so tile + # into overlapping 512x512 windows (single tile on the 512x512 iPSC test). + predict_method: sliding_window predict_overlap: [4, 256, 256] + # predict_blend defaults to "cosine", which cross-fades the overlaps. The + # old plain-average behaviour ("uniform") left step discontinuities where + # the window count changes -- on a 640x960 FOV the y=128 edge measured 7.4x + # its local median step, vs 1.0x for ground truth. Predictions written + # before that default landed carry those seams. + # + # Shift averaging suppresses the two lattices the cosine blend does not + # touch: the decoder's ConvTranspose checkerboard (2/4/8 px) and the ViT + # bottleneck's token grid (32 px). Both are present IN distribution on + # every organelle, not only in the A549-trained-on-iPSC panels -- the 32 px + # grid is the block structure visible in figure panels, because it survives + # the downsampling a figure applies to a 512 px field while the short + # periods average away. In-domain modulation depth (iPSC-trained membrane on + # iPSC, ground-truth floor 0.0705 at P32 and 0.0041 at P4): + # none depth@32 0.9866 depth@4 0.5304 PCC 0.5378 + # these 4 shifts depth@32 0.2338 depth@4 0.0172 PCC 0.5414 + # Written as (dy, dx) PAIRS, which costs 4 tiled passes; a flat + # [0, 5, 11, 22] is expanded to its outer product and costs 16 for the same + # result. Do NOT swap in offsets that merely zero the period-32 phasor -- + # those are congruent mod 8 and reinstate the short periods, measuring two + # to three times worse. See engine._phase_shift_average. + predict_phase_shifts: [[0, 0], [5, 11], [11, 22], [22, 5]] data: init_args: z_window_size: 8 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/unetvit3d_predict.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/unetvit3d_predict.yml index 8d784083b..bfd7486fb 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/unetvit3d_predict.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/unetvit3d_predict.yml @@ -9,8 +9,24 @@ base: - ../../../../../../recipes/topology/single_gpu.yml model: init_args: - predict_method: full_image + # ViT generator is fixed at 512x512; the A549 test set is 640x960, so tile + # into overlapping 512x512 windows (single tile on the 512x512 iPSC test). + predict_method: sliding_window predict_overlap: [4, 256, 256] + # predict_blend defaults to "cosine", which cross-fades the overlaps. The + # old plain-average behaviour ("uniform") left step discontinuities where + # the window count changes -- on a 640x960 FOV the y=128 edge measured 7.4x + # its local median step, vs 1.0x for ground truth. Predictions written + # before that default landed carry those seams. + # + # Not set here: predict_phase_shifts, which additionally suppresses the + # decoder's ConvTranspose checkerboard (2/4/8 px) and the ViT token lattice + # (32 px) at len(offsets)**2 the cost. Both are present IN distribution on + # every organelle -- the 32 px token grid is the block structure visible in + # figure panels. [0, 5, 11, 22] takes its modulation depth 0.99 -> 0.24 + # in-domain (ground-truth floor 0.07). Do NOT swap in offsets that merely + # zero the period-32 phasor; they reinstate the short periods and measure + # worse. See engine._phase_shift_average. data: init_args: z_window_size: 8 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_caax_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_caax_denv_lite.yml new file mode 100644 index 000000000..39aceafad --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_caax_denv_lite.yml @@ -0,0 +1,8 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml. Do not edit; regenerate. +benchmark: + predict_set: a549_mantis_caax_denv_lite + dataset_ref: + dataset: a549-mantis-caax-denv-lite +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: {} diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_caax_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_caax_mock_lite.yml new file mode 100644 index 000000000..317098045 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_caax_mock_lite.yml @@ -0,0 +1,8 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml. Do not edit; regenerate. +benchmark: + predict_set: a549_mantis_caax_mock_lite + dataset_ref: + dataset: a549-mantis-caax-mock-lite +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: {} diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_caax_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_caax_zikv_lite.yml new file mode 100644 index 000000000..30c54a51d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_caax_zikv_lite.yml @@ -0,0 +1,8 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml. Do not edit; regenerate. +benchmark: + predict_set: a549_mantis_caax_zikv_lite + dataset_ref: + dataset: a549-mantis-caax-zikv-lite +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: {} diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_dual_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_dual_denv.yml index 07e196ca7..2c26d7589 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_dual_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_dual_denv.yml @@ -1,12 +1,12 @@ # Predict set: A549 mantis dual Nuclei+Membrane prediction on DENV plate. # No dataset_ref: see predict_sets/ipsc_confocal_dual.yml for rationale. -# Phase3D is byte-equal between CAAX_DENV.ozx and H2B_DENV.ozx (verified at -# Phase 0); CAAX is the canonical pick for input source. +# Nucleus+Membrane targets now share one store (dual_nucl_memb_DENV.zarr), +# from which the Phase3D input source is read. benchmark: predict_set: a549_mantis_dual_denv data: class_path: viscy_data.hcs.HCSDataModule init_args: - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/CAAX_DENV.ozx + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr source_channel: [Phase3D] target_channel: [Nuclei, Membrane] diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_dual_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_dual_mock.yml index 8ad79a38d..4012afe73 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_dual_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_dual_mock.yml @@ -1,12 +1,12 @@ # Predict set: A549 mantis dual Nuclei+Membrane prediction on mock plate. # No dataset_ref: see predict_sets/ipsc_confocal_dual.yml for rationale. -# Phase3D is byte-equal between CAAX_mock.ozx and H2B_mock.ozx (verified at -# Phase 0); CAAX is the canonical pick for input source. +# Nucleus+Membrane targets now share one store (dual_nucl_memb_mock.zarr), +# from which the Phase3D input source is read. benchmark: predict_set: a549_mantis_dual_mock data: class_path: viscy_data.hcs.HCSDataModule init_args: - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/CAAX_mock.ozx + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr source_channel: [Phase3D] target_channel: [Nuclei, Membrane] diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_dual_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_dual_zikv.yml index 0bcd4ff8f..cf573816d 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_dual_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_dual_zikv.yml @@ -1,12 +1,12 @@ # Predict set: A549 mantis dual Nuclei+Membrane prediction on ZIKV plate. # No dataset_ref: see predict_sets/ipsc_confocal_dual.yml for rationale. -# Phase3D is byte-equal between CAAX_ZIKV.ozx and H2B_ZIKV.ozx (verified at -# Phase 0); CAAX is the canonical pick for input source. +# Nucleus+Membrane targets now share one store (dual_nucl_memb_ZIKV.zarr), +# from which the Phase3D input source is read. benchmark: predict_set: a549_mantis_dual_zikv data: class_path: viscy_data.hcs.HCSDataModule init_args: - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/CAAX_ZIKV.ozx + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr source_channel: [Phase3D] target_channel: [Nuclei, Membrane] diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_h2b_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_h2b_denv_lite.yml new file mode 100644 index 000000000..3ea89d5d6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_h2b_denv_lite.yml @@ -0,0 +1,8 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml. Do not edit; regenerate. +benchmark: + predict_set: a549_mantis_h2b_denv_lite + dataset_ref: + dataset: a549-mantis-h2b-denv-lite +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: {} diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_h2b_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_h2b_mock_lite.yml new file mode 100644 index 000000000..cc38ff43c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_h2b_mock_lite.yml @@ -0,0 +1,8 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml. Do not edit; regenerate. +benchmark: + predict_set: a549_mantis_h2b_mock_lite + dataset_ref: + dataset: a549-mantis-h2b-mock-lite +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: {} diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_h2b_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_h2b_zikv_lite.yml new file mode 100644 index 000000000..9db497ad1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_h2b_zikv_lite.yml @@ -0,0 +1,8 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml. Do not edit; regenerate. +benchmark: + predict_set: a549_mantis_h2b_zikv_lite + dataset_ref: + dataset: a549-mantis-h2b-zikv-lite +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: {} diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_sec61b_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_sec61b_denv_lite.yml new file mode 100644 index 000000000..d13006c3b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_sec61b_denv_lite.yml @@ -0,0 +1,8 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml. Do not edit; regenerate. +benchmark: + predict_set: a549_mantis_sec61b_denv_lite + dataset_ref: + dataset: a549-mantis-sec61b-denv-lite +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: {} diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_sec61b_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_sec61b_mock_lite.yml new file mode 100644 index 000000000..6e5cbdd09 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_sec61b_mock_lite.yml @@ -0,0 +1,8 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml. Do not edit; regenerate. +benchmark: + predict_set: a549_mantis_sec61b_mock_lite + dataset_ref: + dataset: a549-mantis-sec61b-mock-lite +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: {} diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv_lite.yml new file mode 100644 index 000000000..50de6d865 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv_lite.yml @@ -0,0 +1,8 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml. Do not edit; regenerate. +benchmark: + predict_set: a549_mantis_sec61b_zikv_lite + dataset_ref: + dataset: a549-mantis-sec61b-zikv-lite +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: {} diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_tomm20_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_tomm20_denv_lite.yml new file mode 100644 index 000000000..b3a6d7f9f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_tomm20_denv_lite.yml @@ -0,0 +1,8 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml. Do not edit; regenerate. +benchmark: + predict_set: a549_mantis_tomm20_denv_lite + dataset_ref: + dataset: a549-mantis-tomm20-denv-lite +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: {} diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_tomm20_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_tomm20_mock_lite.yml new file mode 100644 index 000000000..7a0394dcf --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_tomm20_mock_lite.yml @@ -0,0 +1,8 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml. Do not edit; regenerate. +benchmark: + predict_set: a549_mantis_tomm20_mock_lite + dataset_ref: + dataset: a549-mantis-tomm20-mock-lite +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: {} diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv_lite.yml new file mode 100644 index 000000000..98ec6ed19 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv_lite.yml @@ -0,0 +1,8 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml. Do not edit; regenerate. +benchmark: + predict_set: a549_mantis_tomm20_zikv_lite + dataset_ref: + dataset: a549-mantis-tomm20-zikv-lite +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: {} diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/hek_mantis_dual_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/hek_mantis_dual_a549xy.yml new file mode 100644 index 000000000..d5ddd3356 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/hek_mantis_dual_a549xy.yml @@ -0,0 +1,26 @@ +# Predict set: HEK293T mantis dual Nuclei+Membrane prediction, a549xy geometry. +# +# Purpose: the HEK release ships no nucleus channel (its nucleus target failed +# QC), so the carved whole-cell membrane eval had no seeds to carve. This set +# predicts a nucleus channel from Phase3D with the public VSCyto3D (cytoland) +# checkpoint; the eval then cpdino-segments it into instance seeds and subtracts +# that footprint from the cpdino whole-cell membrane labels. See +# leaf/grouped/membrane_hek_a549xy/eval_grouped.yaml. +# +# No `dataset_ref`: same reason as predict_sets/a549_mantis_dual_mock.yml — the +# manifest schema carries one target_channel per entry and no row declares both +# Nuclei and Membrane, so data_path / source_channel / target_channel are inlined. +# +# `Nuclei` does not exist in the input store, and that is fine: predict never +# reads target channels (HCSDataModule._setup_predict sets only channels.source), +# and HCSPredictionWriter uses target_channel solely to name the output channels +# (`Nuclei_prediction`, `Membrane_prediction`) — it resolves the un-suffixed names +# against the input store only under `write_input`, which stays off. +benchmark: + predict_set: hek_mantis_dual_a549xy +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: + data_path: /hpc/projects/virtual_staining/training/dynacell/hek/mantis/test/KRAS_a549xy.zarr + source_channel: [Phase3D] + target_channel: [Nuclei, Membrane] diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/hek_mantis_kras_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/hek_mantis_kras_a549xy.yml new file mode 100644 index 000000000..31840c36d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/hek_mantis_kras_a549xy.yml @@ -0,0 +1,11 @@ +# Predict set: HEK293T mantis KRAS (membrane) in the a549xy geometry +# (XY resampled to the A549 0.1494 um pitch, Z native 0.205 um). +# data_path resolves to the test store in predict mode via dataset_ref. +# Evaluation-only third-cell-type probe: the manifest defines no train store. +benchmark: + predict_set: hek_mantis_kras_a549xy + dataset_ref: + dataset: hek-mantis-kras-a549xy +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: {} diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/hek_mantis_tomm70a_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/hek_mantis_tomm70a_a549xy.yml new file mode 100644 index 000000000..5cca74580 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/hek_mantis_tomm70a_a549xy.yml @@ -0,0 +1,11 @@ +# Predict set: HEK293T mantis TOMM70A (mitochondria) in the a549xy geometry +# (XY resampled to the A549 0.1494 um pitch, Z native 0.205 um). +# data_path resolves to the test store in predict mode via dataset_ref. +# Evaluation-only third-cell-type probe: the manifest defines no train store. +benchmark: + predict_set: hek_mantis_tomm70a_a549xy + dataset_ref: + dataset: hek-mantis-tomm70a-a549xy +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: {} diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/ipsc_confocal_lite.yml new file mode 100644 index 000000000..75292fcc5 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/ipsc_confocal_lite.yml @@ -0,0 +1,8 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/_internal/shared/model/predict_sets/ipsc_confocal.yml. Do not edit; regenerate. +benchmark: + predict_set: ipsc_confocal_lite + dataset_ref: + dataset: aics-hipsc-lite +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: {} diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/train_sets/a549_mantis_brightfield.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/train_sets/a549_mantis_brightfield.yml new file mode 100644 index 000000000..d8b08d344 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/train_sets/a549_mantis_brightfield.yml @@ -0,0 +1,32 @@ +# Train set: A549 mantis-lightsheet, condition-pooled, BRIGHTFIELD input (ablation). +# +# Identical to a549_mantis.yml except source_channel: the model reads the raw +# `Brightfield` stack instead of the `Phase3D` volume waveorder reconstructs from +# it. Same pooled stores, same targets, same split. +# +# Unlike the iPSC brightfield fragment, this one sets `source_channel` DIRECTLY +# rather than via `dataset_ref.source_channel`: the pooled A549 train stores are +# not in the manifest registry, so leaves on this fragment author +# `data.init_args.{data_path,target_channel}` inline and the resolver hook is a +# strict partial-ref no-op (`dataset_ref.dataset` is never set here). There is no +# manifest to override, so there is nothing for the resolver to splice. +# +# Verified present with normalization statistics at both levels the two recipes +# need (fov mean/std for FNet3D, timepoint p1/p99 for CellDiff): +# mantis_v1/train/H2B_all.zarr [Phase3D, Brightfield, Nuclei] fov mean 1497.5 std 48.0 +# mantis/train/SEC61B_all.zarr [Phase3D, Brightfield, Structure] fov mean 1848.6 std 79.4 +# +# Canonical train_set token is `a549__bf` (paths.py `_TRAIN_ALIAS`), a distinct +# on-disk identity from plain `a549`, so brightfield and phase artifacts never +# share a checkpoint, prediction or eval directory. +benchmark: + train_set: a549_mantis_brightfield + dataset_group: a549-mantis +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: + source_channel: Brightfield + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/train_sets/ipsc_confocal_brightfield.yml b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/train_sets/ipsc_confocal_brightfield.yml new file mode 100644 index 000000000..dadc07549 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/_internal/shared/model/train_sets/ipsc_confocal_brightfield.yml @@ -0,0 +1,29 @@ +# Train set: AICS iPSC confocal, BRIGHTFIELD input (ablation). +# +# Identical to ipsc_confocal.yml except the model input channel: dataset_ref +# carries source_channel: Brightfield, so the resolver splices `Brightfield` +# instead of the manifest's declared `channels.source: Phase3D`. Same dataset, +# same stores, same targets, same splits — only the input volume changes. +# +# `Phase3D` in these stores is RECONSTRUCTED FROM `Brightfield` by waveorder, so +# this arm measures whether that reconstruction buys anything the network cannot +# learn itself. Brightfield is a genuine z-stack (verified: per-plane std sweeps +# 1043 -> 1471 through the 44 planes of train/SEC61B.zarr, zero identical planes), +# carrying ~1.9e4 counts of DC offset that both models' normalizations absorb. +# +# The canonical train_set token is `ipsc__bf` (paths.py `_TRAIN_ALIAS`); it is a +# distinct on-disk identity from plain `ipsc`, so brightfield and phase artifacts +# never share a checkpoint, prediction or eval directory. +benchmark: + train_set: ipsc_confocal_brightfield + dataset_group: aics-hipsc + dataset_ref: + dataset: aics-hipsc + source_channel: Brightfield +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_denv.yml index 9933cf9ea..08f0c1714 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_denv.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/er_sec61b.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/sec61b/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/celldiff_r2/checkpoints/epoch=19-step=66240-v1.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_celldiff_r2_a549trained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/a549__denv/prediction.zarr launcher: job_name: CELLDiff_A549_PRED_SEC61B_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..4913af62d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_denv_lite + model_name: celldiff + experiment_id: er__a549_mantis__celldiff__a549_mantis_sec61b_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/celldiff_r2/checkpoints/epoch=19-step=66240-v1.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/a549/a549__denv/prediction.zarr +launcher: + job_name: CELLDiff_A549_PRED_SEC61B_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_mock.yml index 7e6d82de4..9047ee722 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_mock.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/er_sec61b.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/sec61b/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/celldiff_r2/checkpoints/epoch=19-step=66240-v1.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_celldiff_r2_a549trained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/a549__mock/prediction.zarr launcher: job_name: CELLDiff_A549_PRED_SEC61B_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..ce49ee456 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_mock_lite + model_name: celldiff + experiment_id: er__a549_mantis__celldiff__a549_mantis_sec61b_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/celldiff_r2/checkpoints/epoch=19-step=66240-v1.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/a549/a549__mock/prediction.zarr +launcher: + job_name: CELLDiff_A549_PRED_SEC61B_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_zikv.yml index 462a31c6f..ed10a2601 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_zikv.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/er_sec61b.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/sec61b/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/celldiff_r2/checkpoints/epoch=19-step=66240-v1.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_celldiff_r2_a549trained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/a549__zikv/prediction.zarr launcher: job_name: CELLDiff_A549_PRED_SEC61B_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..ca492b7f9 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_zikv_lite + model_name: celldiff + experiment_id: er__a549_mantis__celldiff__a549_mantis_sec61b_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/celldiff_r2/checkpoints/epoch=19-step=66240-v1.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/a549/a549__zikv/prediction.zarr +launcher: + job_name: CELLDiff_A549_PRED_SEC61B_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__ipsc_confocal.yml index e9993ec75..1d6138cc5 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__ipsc_confocal.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/er_sec61b.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/sec61b/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/celldiff_r2/checkpoints/epoch=19-step=66240-v1.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_celldiff_r2_a549trained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/ipsc/prediction.zarr launcher: job_name: CELLDiff_A549_PRED_SEC61B_ON_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..13e1acc43 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: ipsc_confocal_lite + model_name: celldiff + experiment_id: er__a549_mantis__celldiff__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/celldiff_r2/checkpoints/epoch=19-step=66240-v1.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 40 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/a549/ipsc/prediction.zarr +launcher: + job_name: CELLDiff_A549_PRED_SEC61B_ON_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/train.yml index 946053d7a..64beda2be 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis/train.yml @@ -19,7 +19,7 @@ trainer: logger: init_args: name: CELLDiff_A549_SEC61B - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/sec61b/celldiff_r2 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/celldiff_r2 callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -29,14 +29,14 @@ trainer: every_n_epochs: 1 save_top_k: -1 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/sec61b/celldiff_r2/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/celldiff_r2/checkpoints data: init_args: # A549 pooled store + target_channel — no resolver in this train_set. target_channel: Structure - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/SEC61B_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all.zarr launcher: job_name: CELLDiff_A549_SEC61B - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/sec61b/celldiff_r2 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/celldiff_r2 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..f4c1eea50 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# CELLDiffBF predict: er trained on a549_mantis_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_sec61b_denv. +# +# Brightfield-input ablation arm of +# er/celldiff/a549_mantis/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `a549__bf`). +# +# save_top_k: -1 with no monitor on this arm, so the checkpoint is the FINAL +# epoch chosen explicitly, matching how the phase baseline pinned its own. +# +# A549 manifest keys er by gene (`sec61b`); override the iPSC-side +# `er` target_id from targets/er_sec61b.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis_brightfield + predict_set: a549_mantis_sec61b_denv + model_name: celldiff + experiment_id: er__a549_mantis_brightfield__celldiff__a549_mantis_sec61b_denv + dataset_ref: + source_channel: Brightfield + target: sec61b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/er/celldiff_r2/checkpoints/epoch=19-step=66240.ckpt + predict_method: iterative + predict_overlap: [4, 256, 256] + +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + augmentations: [] + z_window_size: 48 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/a549__bf/a549__denv/prediction.zarr + +launcher: + job_name: CELLDiffBF_PRED_SEC61B_A549TR_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/a549__bf/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..dedcb5e61 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# CELLDiffBF predict: er trained on a549_mantis_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_sec61b_mock. +# +# Brightfield-input ablation arm of +# er/celldiff/a549_mantis/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `a549__bf`). +# +# save_top_k: -1 with no monitor on this arm, so the checkpoint is the FINAL +# epoch chosen explicitly, matching how the phase baseline pinned its own. +# +# A549 manifest keys er by gene (`sec61b`); override the iPSC-side +# `er` target_id from targets/er_sec61b.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis_brightfield + predict_set: a549_mantis_sec61b_mock + model_name: celldiff + experiment_id: er__a549_mantis_brightfield__celldiff__a549_mantis_sec61b_mock + dataset_ref: + source_channel: Brightfield + target: sec61b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/er/celldiff_r2/checkpoints/epoch=19-step=66240.ckpt + predict_method: iterative + predict_overlap: [4, 256, 256] + +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + augmentations: [] + z_window_size: 48 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/a549__bf/a549__mock/prediction.zarr + +launcher: + job_name: CELLDiffBF_PRED_SEC61B_A549TR_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/a549__bf/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..dbb65d6f6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# CELLDiffBF predict: er trained on a549_mantis_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_sec61b_zikv. +# +# Brightfield-input ablation arm of +# er/celldiff/a549_mantis/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `a549__bf`). +# +# save_top_k: -1 with no monitor on this arm, so the checkpoint is the FINAL +# epoch chosen explicitly, matching how the phase baseline pinned its own. +# +# A549 manifest keys er by gene (`sec61b`); override the iPSC-side +# `er` target_id from targets/er_sec61b.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis_brightfield + predict_set: a549_mantis_sec61b_zikv + model_name: celldiff + experiment_id: er__a549_mantis_brightfield__celldiff__a549_mantis_sec61b_zikv + dataset_ref: + source_channel: Brightfield + target: sec61b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/er/celldiff_r2/checkpoints/epoch=19-step=66240.ckpt + predict_method: iterative + predict_overlap: [4, 256, 256] + +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + augmentations: [] + z_window_size: 48 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/a549__bf/a549__zikv/prediction.zarr + +launcher: + job_name: CELLDiffBF_PRED_SEC61B_A549TR_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/a549__bf/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/predict__ipsc_confocal__iterative.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/predict__ipsc_confocal__iterative.yml new file mode 100644 index 000000000..38cdad21b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/predict__ipsc_confocal__iterative.yml @@ -0,0 +1,55 @@ +# CELLDiffBF predict: er trained on a549_mantis_brightfield, BRIGHTFIELD input, +# predicting against ipsc_confocal. +# +# Brightfield-input ablation arm of +# er/celldiff/a549_mantis/predict__ipsc*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `a549__bf`). +# +# save_top_k: -1 with no monitor on this arm, so the checkpoint is the FINAL +# epoch chosen explicitly, matching how the phase baseline pinned its own. + +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis_brightfield + predict_set: ipsc_confocal + model_name: celldiff + experiment_id: er__a549_mantis_brightfield__celldiff__ipsc_confocal__iterative + dataset_ref: + source_channel: Brightfield + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/er/celldiff_r2/checkpoints/epoch=19-step=66240.ckpt + predict_method: iterative + predict_overlap: [4, 256, 256] + +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + augmentations: [] + z_window_size: 40 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/a549__bf/ipsc/prediction.zarr + +launcher: + job_name: CELLDiffBF_PRED_SEC61B_A549TR_ITER_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/a549__bf/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/train.yml new file mode 100644 index 000000000..4fa0f487d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/a549_mantis_brightfield/train.yml @@ -0,0 +1,71 @@ +# CellDiff fit on ER (SEC61B marker) — A549 mantis-lightsheet pooled, BRIGHTFIELD input. +# +# Brightfield-input ablation arm of er/celldiff/a549_mantis/train.yml. Every +# hyperparameter is identical to that baseline; the only change is the model input +# channel (Brightfield instead of the Phase3D volume reconstructed from it), which +# enters via train_sets/a549_mantis_brightfield.yml's source_channel. +# +# Only the two channel-named lists are re-authored. gpu_augmentations and +# val_gpu_augmentations key on `source`/`target` (post-collation names), so they are +# channel-agnostic and inherited from data_overlays/celldiff_fit.yml untouched. +# val_augmentations is deliberately absent, matching the baseline. +# +# The pooled store also carries `Structure_deconvolved`; the target is the raw +# `Structure`, matching the baseline (the deconv token is retired). +base: + - ../../../_internal/shared/model/train_sets/a549_mantis_brightfield.yml + - ../../../_internal/shared/model/targets/er_sec61b_celldiff.yml + - ../../../_internal/shared/model/data_overlays/celldiff_fit.yml + - ../../../_internal/shared/model/model_overlays/celldiff_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + train_set: a549_mantis_brightfield + model_name: celldiff + experiment_id: er__a549_mantis_brightfield__celldiff + +data: + init_args: + # A549 pooled store + target_channel — no resolver in this train_set. + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all.zarr + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Structure] + level: timepoint_statistics + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Brightfield, Structure] + w_key: Structure + spatial_size: [13, 624, 624] + num_samples: 2 + +trainer: + logger: + init_args: + name: CELLDiff_A549bf_SEC61B + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/er/celldiff_r2 + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + every_n_epochs: 1 + save_top_k: -1 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/er/celldiff_r2/checkpoints + +launcher: + job_name: CELLDiffBF_A549_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/er/celldiff_r2 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index deb70ecb5..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by CellDiff on a549-mantis-sec61b-denv. -defaults: - - override /target: er_sec61b - - override /predict_set: a549_mantis_sec61b_denv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_celldiff_iterative__sec61b_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_sec61b_celldiff_iterative__sec61b_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index 6a78964f9..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by CellDiff on a549-mantis-sec61b-mock. -defaults: - - override /target: er_sec61b - - override /predict_set: a549_mantis_sec61b_mock - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_celldiff_iterative__sec61b_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_sec61b_celldiff_iterative__sec61b_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index acd167801..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by CellDiff on a549-mantis-sec61b-zikv. -defaults: - - override /target: er_sec61b - - override /predict_set: a549_mantis_sec61b_zikv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_celldiff_iterative__sec61b_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_sec61b_celldiff_iterative__sec61b_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 100644 index e11c6a274..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by CellDiff on iPSC confocal. -defaults: - - override /target: er_sec61b - - override /predict_set: ipsc_confocal - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_celldiff_iterative.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/eval_sec61b_celldiff_iterative diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml index 21d73c326..95171b078 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/er_sec61b.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_r2/checkpoints/epoch=19-step=108160.ckpt predict_method: iterative # denoise, generate, sliding_window, or iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_celldiff_r2_iterative__sec61b_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr launcher: job_name: CELLDiff_PRED_SEC61B_ON_A549_sec61b_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..7de0467ea --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_denv_lite + model_name: celldiff + experiment_id: er__ipsc_confocal__celldiff__a549_mantis_sec61b_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_r2/checkpoints/epoch=19-step=108160.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr +launcher: + job_name: CELLDiff_PRED_SEC61B_ON_A549_sec61b_denv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2_iterative/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml index f804ff5cf..3055a7a3c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/er_sec61b.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_r2/checkpoints/epoch=19-step=108160.ckpt predict_method: iterative # denoise, generate, sliding_window, or iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_celldiff_r2_iterative__sec61b_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr launcher: job_name: CELLDiff_PRED_SEC61B_ON_A549_sec61b_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..0de093886 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_mock_lite + model_name: celldiff + experiment_id: er__ipsc_confocal__celldiff__a549_mantis_sec61b_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_r2/checkpoints/epoch=19-step=108160.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr +launcher: + job_name: CELLDiff_PRED_SEC61B_ON_A549_sec61b_mock_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2_iterative/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml index cc8fd0a1e..53b1c949d 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/er_sec61b.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_r2/checkpoints/epoch=19-step=108160.ckpt predict_method: iterative # denoise, generate, sliding_window, or iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_celldiff_r2_iterative__sec61b_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr launcher: job_name: CELLDiff_PRED_SEC61B_ON_A549_sec61b_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..74a5c64a1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_zikv_lite + model_name: celldiff + experiment_id: er__ipsc_confocal__celldiff__a549_mantis_sec61b_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_r2/checkpoints/epoch=19-step=108160.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: CELLDiff_PRED_SEC61B_ON_A549_sec61b_zikv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2_iterative/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__ipsc_confocal__denoise.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__ipsc_confocal__denoise.yml index 9df6078d8..c9aab40bf 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__ipsc_confocal__denoise.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__ipsc_confocal__denoise.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/er_sec61b.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_r2/checkpoints/epoch=19-step=108160.ckpt predict_method: denoise predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_celldiff_r2_denoise.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_denoise/ipsc/ipsc/prediction.zarr launcher: job_name: CELLDiff_PRED_SEC61B_DN - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_denoise/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml index dc89acf8e..3dc3252ab 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/er_sec61b.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_r2/checkpoints/epoch=19-step=108160.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_celldiff_r2_iterative.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr launcher: job_name: CELLDiff_PRED_SEC61B_ITER - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative_lite.yml new file mode 100644 index 000000000..5c14ac2e5 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: celldiff + experiment_id: er__ipsc_confocal__celldiff__ipsc_confocal__iterative__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_r2/checkpoints/epoch=19-step=108160.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 40 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr +launcher: + job_name: CELLDiff_PRED_SEC61B_ITER_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2_iterative/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__ipsc_confocal__sliding_window.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__ipsc_confocal__sliding_window.yml index 820af3536..c1c816306 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__ipsc_confocal__sliding_window.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/predict__ipsc_confocal__sliding_window.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/er_sec61b.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_r2/checkpoints/epoch=19-step=108160.ckpt predict_method: sliding_window predict_overlap: [0, 0, 0] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_celldiff_r2_sliding_window.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_sliding_window/ipsc/ipsc/prediction.zarr launcher: job_name: CELLDiff_PRED_SEC61B_SW - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_sliding_window/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/train.yml index 9d96e154a..0b16f934d 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal/train.yml @@ -19,7 +19,7 @@ trainer: logger: init_args: name: CELLDiff_iPSC_SEC61B - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/celldiff_r2 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_r2 callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -29,8 +29,8 @@ trainer: every_n_epochs: 1 save_top_k: -1 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/celldiff_r2/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_r2/checkpoints launcher: job_name: CELLDiff_SEC61B - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/celldiff_r2 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_r2 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..611e0db62 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# CELLDiffBF predict: er trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_sec61b_denv. +# +# Brightfield-input ablation arm of +# er/celldiff/ipsc_confocal/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `ipsc__bf`). +# +# save_top_k: -1 with no monitor on this arm, so the checkpoint is the FINAL +# epoch chosen explicitly, matching how the phase baseline pinned its own. +# +# A549 manifest keys er by gene (`sec61b`); override the iPSC-side +# `er` target_id from targets/er_sec61b.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal_brightfield + predict_set: a549_mantis_sec61b_denv + model_name: celldiff + experiment_id: er__ipsc_confocal_brightfield__celldiff__a549_mantis_sec61b_denv + dataset_ref: + source_channel: Brightfield + target: sec61b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/er/celldiff_r2/checkpoints/epoch=19-step=108160.ckpt + predict_method: iterative + predict_overlap: [4, 256, 256] + +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + augmentations: [] + z_window_size: 48 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc__bf/a549__denv/prediction.zarr + +launcher: + job_name: CELLDiffBF_PRED_SEC61B_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc__bf/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..4f4fa9377 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# CELLDiffBF predict: er trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_sec61b_mock. +# +# Brightfield-input ablation arm of +# er/celldiff/ipsc_confocal/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `ipsc__bf`). +# +# save_top_k: -1 with no monitor on this arm, so the checkpoint is the FINAL +# epoch chosen explicitly, matching how the phase baseline pinned its own. +# +# A549 manifest keys er by gene (`sec61b`); override the iPSC-side +# `er` target_id from targets/er_sec61b.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal_brightfield + predict_set: a549_mantis_sec61b_mock + model_name: celldiff + experiment_id: er__ipsc_confocal_brightfield__celldiff__a549_mantis_sec61b_mock + dataset_ref: + source_channel: Brightfield + target: sec61b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/er/celldiff_r2/checkpoints/epoch=19-step=108160.ckpt + predict_method: iterative + predict_overlap: [4, 256, 256] + +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + augmentations: [] + z_window_size: 48 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc__bf/a549__mock/prediction.zarr + +launcher: + job_name: CELLDiffBF_PRED_SEC61B_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc__bf/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..baa6dd69c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# CELLDiffBF predict: er trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_sec61b_zikv. +# +# Brightfield-input ablation arm of +# er/celldiff/ipsc_confocal/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `ipsc__bf`). +# +# save_top_k: -1 with no monitor on this arm, so the checkpoint is the FINAL +# epoch chosen explicitly, matching how the phase baseline pinned its own. +# +# A549 manifest keys er by gene (`sec61b`); override the iPSC-side +# `er` target_id from targets/er_sec61b.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal_brightfield + predict_set: a549_mantis_sec61b_zikv + model_name: celldiff + experiment_id: er__ipsc_confocal_brightfield__celldiff__a549_mantis_sec61b_zikv + dataset_ref: + source_channel: Brightfield + target: sec61b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/er/celldiff_r2/checkpoints/epoch=19-step=108160.ckpt + predict_method: iterative + predict_overlap: [4, 256, 256] + +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + augmentations: [] + z_window_size: 48 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc__bf/a549__zikv/prediction.zarr + +launcher: + job_name: CELLDiffBF_PRED_SEC61B_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc__bf/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/predict__ipsc_confocal__iterative.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/predict__ipsc_confocal__iterative.yml new file mode 100644 index 000000000..f88f7ebea --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/predict__ipsc_confocal__iterative.yml @@ -0,0 +1,55 @@ +# CELLDiffBF predict: er trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against ipsc_confocal. +# +# Brightfield-input ablation arm of +# er/celldiff/ipsc_confocal/predict__ipsc*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `ipsc__bf`). +# +# save_top_k: -1 with no monitor on this arm, so the checkpoint is the FINAL +# epoch chosen explicitly, matching how the phase baseline pinned its own. + +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal_brightfield + predict_set: ipsc_confocal + model_name: celldiff + experiment_id: er__ipsc_confocal_brightfield__celldiff__ipsc_confocal__iterative + dataset_ref: + source_channel: Brightfield + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/er/celldiff_r2/checkpoints/epoch=19-step=108160.ckpt + predict_method: iterative + predict_overlap: [4, 256, 256] + +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + augmentations: [] + z_window_size: 40 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc__bf/ipsc/prediction.zarr + +launcher: + job_name: CELLDiffBF_PRED_SEC61B_ITER + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2_iterative/ipsc__bf/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/train.yml new file mode 100644 index 000000000..9a44522be --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/ipsc_confocal_brightfield/train.yml @@ -0,0 +1,65 @@ +# CellDiff fit on ER (SEC61B marker) — AICS iPSC confocal, BRIGHTFIELD input. +# +# Brightfield-input ablation arm of er/celldiff/ipsc_confocal/train.yml. Every +# hyperparameter is identical to that baseline; the only change is the model input +# channel (Brightfield instead of the Phase3D volume reconstructed from it), which +# enters via train_sets/ipsc_confocal_brightfield.yml's dataset_ref.source_channel. +# +# Only the two channel-named lists are re-authored. gpu_augmentations and +# val_gpu_augmentations key on `source`/`target` (post-collation names), so they are +# channel-agnostic and inherited from data_overlays/celldiff_fit.yml untouched. +# val_augmentations is deliberately absent, matching the baseline. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal_brightfield.yml + - ../../../_internal/shared/model/targets/er_sec61b_celldiff.yml + - ../../../_internal/shared/model/data_overlays/celldiff_fit.yml + - ../../../_internal/shared/model/model_overlays/celldiff_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + train_set: ipsc_confocal_brightfield + model_name: celldiff + experiment_id: er__ipsc_confocal_brightfield__celldiff + +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Structure] + level: timepoint_statistics + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Brightfield, Structure] + w_key: Structure + spatial_size: [13, 624, 624] + num_samples: 2 + +trainer: + logger: + init_args: + name: CELLDiff_iPSCbf_SEC61B + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/er/celldiff_r2 + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + every_n_epochs: 1 + save_top_k: -1 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/er/celldiff_r2/checkpoints + +launcher: + job_name: CELLDiffBF_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/er/celldiff_r2 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index f39c43165..4a786df8b 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/er_sec61b.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/sec61b/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_r2/checkpoints/epoch=19-step=176560-v1.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/sec61b_celldiff_r2_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/a549__denv/prediction.zarr launcher: job_name: CELLDiff_JOINT_PRED_SEC61B_ON_A549_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..00c174385 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_denv_lite + model_name: celldiff + experiment_id: er__joint_ipsc_confocal_a549_mantis__celldiff__a549_mantis_sec61b_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_r2/checkpoints/epoch=19-step=176560-v1.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/joint/a549__denv/prediction.zarr +launcher: + job_name: CELLDiff_JOINT_PRED_SEC61B_ON_A549_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index b829c3aa4..42c8ad728 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/er_sec61b.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/sec61b/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_r2/checkpoints/epoch=19-step=176560-v1.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/sec61b_celldiff_r2_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/a549__mock/prediction.zarr launcher: job_name: CELLDiff_JOINT_PRED_SEC61B_ON_A549_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..f0275d4d0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_mock_lite + model_name: celldiff + experiment_id: er__joint_ipsc_confocal_a549_mantis__celldiff__a549_mantis_sec61b_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_r2/checkpoints/epoch=19-step=176560-v1.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/joint/a549__mock/prediction.zarr +launcher: + job_name: CELLDiff_JOINT_PRED_SEC61B_ON_A549_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index 06fa202d2..d806f537e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/er_sec61b.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/sec61b/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_r2/checkpoints/epoch=19-step=176560-v1.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/sec61b_celldiff_r2_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/a549__zikv/prediction.zarr launcher: job_name: CELLDiff_JOINT_PRED_SEC61B_ON_A549_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..d7f08d4e4 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_zikv_lite + model_name: celldiff + experiment_id: er__joint_ipsc_confocal_a549_mantis__celldiff__a549_mantis_sec61b_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_r2/checkpoints/epoch=19-step=176560-v1.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/joint/a549__zikv/prediction.zarr +launcher: + job_name: CELLDiff_JOINT_PRED_SEC61B_ON_A549_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index d02c88a9f..647a3d976 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/er_sec61b.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/sec61b/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_r2/checkpoints/epoch=19-step=176560-v1.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/sec61b_celldiff_r2.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/ipsc/prediction.zarr launcher: job_name: CELLDiff_JOINT_PRED_SEC61B_ON_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_r2/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..3511d4bf0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal_lite + model_name: celldiff + experiment_id: er__joint_ipsc_confocal_a549_mantis__celldiff__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_r2/checkpoints/epoch=19-step=176560-v1.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 40 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/joint/ipsc/prediction.zarr +launcher: + job_name: CELLDiff_JOINT_PRED_SEC61B_ON_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/celldiff_r2/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/train.yml index 9b8d5d6fe..fad443c2e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/train.yml @@ -29,7 +29,7 @@ trainer: logger: init_args: name: CELLDiff_JOINT_SEC61B - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/sec61b/celldiff_r2 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_r2 callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -39,7 +39,7 @@ trainer: every_n_epochs: 1 save_top_k: -1 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/sec61b/celldiff_r2/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_r2/checkpoints # Child HCSDataModule init_args shared across both datasets (only data_path # differs). Factored as a YAML anchor so the joint leaf stays auditable; @@ -132,15 +132,15 @@ data: init_args: <<: *hcs_init_args data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B.zarr - # a549_mantis — pooled SEC61B all-conditions train store (mantis_v1/train/SEC61B_all.zarr) + # a549_mantis — pooled SEC61B all-conditions train store (mantis/train/SEC61B_all.zarr) - class_path: viscy_data.hcs.HCSDataModule init_args: <<: *hcs_init_args - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/SEC61B_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all.zarr launcher: job_name: CELLDiff_JOINT_SEC61B - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/sec61b/celldiff_r2 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_r2 # Joint preloads two stores (iPSC + A549 pool) into /dev/shm; the default # 256G cap is too tight (256G iPSC mem + ~50G A549 + worker peak OOMs). # 512G is the smallest tier that fits joint preload + worker overhead. diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/train_smoke.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/train_smoke.yml index 60bac2fe9..60a704a80 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/train_smoke.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/train_smoke.yml @@ -138,4 +138,4 @@ data: launcher: job_name: CELLDiff_JOINT_SEC61B_SMOKE - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/sec61b/celldiff_r2/smoke + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_r2/smoke diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/train_smoke_4gpu.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/train_smoke_4gpu.yml index 06ed4f0cb..802961906 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/train_smoke_4gpu.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff/joint_ipsc_confocal_a549_mantis/train_smoke_4gpu.yml @@ -155,4 +155,4 @@ data: launcher: job_name: CELLDiff_JOINT_SEC61B_SMOKE_4GPU - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/sec61b/celldiff_r2/smoke_4gpu + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_r2/smoke_4gpu diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..41f7753dd --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: er trained on a549_mantis, tested on a549-mantis-sec61b-denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_denv + model_name: celldiff_2d + experiment_id: er__a549_mantis__celldiff_2d__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/celldiff_2d/checkpoints/epoch=19-step=9340.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/a549__denv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_A549_SEC61B_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..7a47ac192 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: er trained on a549_mantis, tested on a549-mantis-sec61b-mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_mock + model_name: celldiff_2d + experiment_id: er__a549_mantis__celldiff_2d__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/celldiff_2d/checkpoints/epoch=19-step=9340.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/a549__mock/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_A549_SEC61B_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..c1eda65fd --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: er trained on a549_mantis, tested on a549-mantis-sec61b-zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_zikv + model_name: celldiff_2d + experiment_id: er__a549_mantis__celldiff_2d__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/celldiff_2d/checkpoints/epoch=19-step=9340.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/a549__zikv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_A549_SEC61B_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..04c05398e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: er trained on a549_mantis, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: celldiff_2d + experiment_id: er__a549_mantis__celldiff_2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/celldiff_2d/checkpoints/epoch=19-step=9340.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/ipsc/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_A549_SEC61B_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/train.yml new file mode 100644 index 000000000..30080ba33 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/a549_mantis/train.yml @@ -0,0 +1,82 @@ +# CellDiff-2D (CELLDiffNet run Z-preserving at Z=1) fit on er (Structure +# channel) — a549_mantis, in-focus 2D track. Mirror of the 3D +# er/celldiff/a549_mantis fit leaf, flattened onto the offline +# 5-plane in-focus slab store (z_window_size=1 emits one in-focus window +# per plane). +# +# The 3D leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus store. +# The 2D track reads the `_focus.zarr` slab instead, so the resolver is +# disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field +# co-declared with a full dataset_ref. +# +# The train_set fragment supplies data.class_path (HCSDataModule) plus +# split_ratio / mmap_preload / scratch_dir — without it the resolved +# config has an init_args-only data block and `dynacell fit` fails to +# build the datamodule. targets/er_celldiff.yml supplies the +# MinMaxSampled(timepoint_statistics) normalization CellDiff needs +# (p1/p99 -> [-1,1], not mean/std); only its RandWeightedCropd is +# list-replaced below, flattened [13,624,624] -> [1,624,624]. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/er_sec61b_celldiff.yml + - ../../../_internal/shared/model/data_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + gene: SEC61B + target: er + target_id: er + train_set: a549_mantis + model_name: celldiff_2d + experiment_id: er__a549_mantis__celldiff_2d + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered non-focus store. + dataset_ref: null + +data: + init_args: + # pooled SEC61B all-conditions in-focus slab store — resolver disabled above. + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all_focus.zarr + # Flatten the target fragment's [13, 624, 624] weighted crop to Z=1. + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 624, 624] + num_samples: 2 + + +trainer: + logger: + init_args: + name: CELLDiff2D_A549_SEC61B + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/celldiff_2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + every_n_epochs: 1 + save_top_k: -1 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/celldiff_2d/checkpoints + +launcher: + job_name: CELLDiff2D_A549_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/celldiff_2d + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D + # store (~1/4 the Z), so the 512G headroom the 3D leaf needed for + # mmap_preload is wasteful and delays scheduling. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..8e3fe21e1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: er trained on ipsc_confocal, tested on a549-mantis-sec61b-denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_denv + model_name: celldiff_2d + experiment_id: er__ipsc_confocal__celldiff_2d__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_2d/checkpoints/epoch=19-step=16900.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_SEC61B_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..fb184b5bf --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: er trained on ipsc_confocal, tested on a549-mantis-sec61b-mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_mock + model_name: celldiff_2d + experiment_id: er__ipsc_confocal__celldiff_2d__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_2d/checkpoints/epoch=19-step=16900.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_SEC61B_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..f18ab8988 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: er trained on ipsc_confocal, tested on a549-mantis-sec61b-zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_zikv + model_name: celldiff_2d + experiment_id: er__ipsc_confocal__celldiff_2d__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_2d/checkpoints/epoch=19-step=16900.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_SEC61B_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..34303de70 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: er trained on ipsc_confocal, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: celldiff_2d + experiment_id: er__ipsc_confocal__celldiff_2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_2d/checkpoints/epoch=19-step=16900.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/ipsc/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_SEC61B_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/train.yml new file mode 100644 index 000000000..00bf19381 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/ipsc_confocal/train.yml @@ -0,0 +1,82 @@ +# CellDiff-2D (CELLDiffNet run Z-preserving at Z=1) fit on er (Structure +# channel) — ipsc_confocal, in-focus 2D track. Mirror of the 3D +# er/celldiff/ipsc_confocal fit leaf, flattened onto the offline +# 5-plane in-focus slab store (z_window_size=1 emits one in-focus window +# per plane). +# +# The 3D leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus store. +# The 2D track reads the `_focus.zarr` slab instead, so the resolver is +# disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field +# co-declared with a full dataset_ref. +# +# The train_set fragment supplies data.class_path (HCSDataModule) plus +# split_ratio / mmap_preload / scratch_dir — without it the resolved +# config has an init_args-only data block and `dynacell fit` fails to +# build the datamodule. targets/er_celldiff.yml supplies the +# MinMaxSampled(timepoint_statistics) normalization CellDiff needs +# (p1/p99 -> [-1,1], not mean/std); only its RandWeightedCropd is +# list-replaced below, flattened [13,624,624] -> [1,624,624]. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b_celldiff.yml + - ../../../_internal/shared/model/data_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + gene: SEC61B + target: er + target_id: er + train_set: ipsc_confocal + model_name: celldiff_2d + experiment_id: er__ipsc_confocal__celldiff_2d + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered non-focus store. + dataset_ref: null + +data: + init_args: + # aics-hipsc SEC61B in-focus slab store — resolver disabled above. + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B_focus.zarr + # Flatten the target fragment's [13, 624, 624] weighted crop to Z=1. + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 624, 624] + num_samples: 2 + + +trainer: + logger: + init_args: + name: CELLDiff2D_iPSC_SEC61B + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + every_n_epochs: 1 + save_top_k: -1 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_2d/checkpoints + +launcher: + job_name: CELLDiff2D_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/celldiff_2d + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D + # store (~1/4 the Z), so the 512G headroom the 3D leaf needed for + # mmap_preload is wasteful and delays scheduling. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..d12b56f26 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: er trained on joint_ipsc_confocal_a549_mantis, tested on a549-mantis-sec61b-denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_denv + model_name: celldiff_2d + experiment_id: er__joint_ipsc_confocal_a549_mantis__celldiff_2d__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_2d/checkpoints/epoch=19-step=26400.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/a549__denv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_JOINT_SEC61B_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..2d66859ae --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: er trained on joint_ipsc_confocal_a549_mantis, tested on a549-mantis-sec61b-mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_mock + model_name: celldiff_2d + experiment_id: er__joint_ipsc_confocal_a549_mantis__celldiff_2d__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_2d/checkpoints/epoch=19-step=26400.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/a549__mock/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_JOINT_SEC61B_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..0a94ab442 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: er trained on joint_ipsc_confocal_a549_mantis, tested on a549-mantis-sec61b-zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_zikv + model_name: celldiff_2d + experiment_id: er__joint_ipsc_confocal_a549_mantis__celldiff_2d__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_2d/checkpoints/epoch=19-step=26400.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/a549__zikv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_JOINT_SEC61B_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..43ebf71cb --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: er trained on joint_ipsc_confocal_a549_mantis, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: celldiff_2d + experiment_id: er__joint_ipsc_confocal_a549_mantis__celldiff_2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_2d/checkpoints/epoch=19-step=26400.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/ipsc/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_JOINT_SEC61B_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/celldiff_2d/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..c8349b29a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/celldiff_2d/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,138 @@ +# CellDiff-2D (CELLDiffNet run Z-preserving at Z=1) fit on er (Structure) +# — joint ipsc_confocal + a549_mantis pooled, in-focus 2D track. Mirror of +# the 3D er/celldiff/joint_* fit leaf, flattened onto the offline +# 5-plane in-focus slab stores. +# +# BatchedConcatDataModule + two explicit HCSDataModule children; only +# model_overlays/celldiff_2d_fit.yml is composed (the data block is +# authored inline here, not via data_overlays). +# +# batch_size 2 here, NOT the single-set 4: BatchedConcatDataModule's +# train_dataloader uses batch_size as-is, while HCSDataModule divides by +# RandWeightedCropd num_samples. 2 indices * 2 num_samples = 4 GPU +# samples, matching the single-set leaves. +base: + - ../../../_internal/shared/model/model_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + gene: SEC61B + target: er + target_id: er + train_set: joint_ipsc_confocal_a549_mantis + model_name: celldiff_2d + experiment_id: er__joint_ipsc_confocal_a549_mantis__celldiff_2d + +trainer: + logger: + init_args: + name: CELLDiff2D_JOINT_SEC61B + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + every_n_epochs: 1 + save_top_k: -1 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_2d/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Structure + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: [512, 512] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Structure] + level: timepoint_statistics + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 624, 624] + num_samples: 2 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [0, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[1, 1], [0.5, 1.5], [0.5, 1.5]] + safe_crop_size: [1, 512, 512] + safe_crop_coverage: 0.9 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0, 0] + val_gpu_augmentations: + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] + + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc SEC61B in-focus slab store + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B_focus.zarr + # a549_mantis — pooled SEC61B all-conditions in-focus slab store + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all_focus.zarr + +launcher: + job_name: CELLDiff2D_JOINT_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/celldiff_2d + # 128G: both children preload 5-plane in-focus slabs (~1/4 the Z of the + # 3D stores), so the 512G the 3D joint leaf needed is wasteful here. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..ea60511ef --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: er trained on a549_mantis, +# tested on a549-mantis-sec61b-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_denv + model_name: fcmae_vscyto2d_pretrained + experiment_id: er__a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto2d_pretrained/checkpoints/epoch=23-step=5520-loss=0.497.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_A549TR_SEC61B_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..9b3b54506 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: er trained on a549_mantis, +# tested on a549-mantis-sec61b-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_mock + model_name: fcmae_vscyto2d_pretrained + experiment_id: er__a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto2d_pretrained/checkpoints/epoch=23-step=5520-loss=0.497.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_A549TR_SEC61B_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..c287059f1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: er trained on a549_mantis, +# tested on a549-mantis-sec61b-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_zikv + model_name: fcmae_vscyto2d_pretrained + experiment_id: er__a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto2d_pretrained/checkpoints/epoch=23-step=5520-loss=0.497.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_A549TR_SEC61B_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..500567162 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: er trained on a549_mantis, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_pretrained + experiment_id: er__a549_mantis__fcmae_vscyto2d_pretrained__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto2d_pretrained/checkpoints/epoch=23-step=5520-loss=0.497.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_A549TR_SEC61B_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/train.yml new file mode 100644 index 000000000..5a99f6d04 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/a549_mantis/train.yml @@ -0,0 +1,73 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) with FCMAE-2D +# pretrained encoder init on ER/SEC61B, in-focus 2D benchmark track, +# A549 mantis pooled (mock + DENV + ZIKV). Paper key: VSCyto2D. Companion +# to fcmae_vscyto2d_scratch — the two leaves are identical except this one +# loads the 2D FCMAE encoder weights and drops lr to 0.0002 (mirroring +# cytoland VSCyto2D finetuning). +# +# Reads the offline 5-plane in-focus slab store SEC61B_all_focus.zarr +# (z_window_size=1 emits one in-focus window per plane). target_channel +# "Structure" matches the FCMAE-2D data overlay's default augmentation +# keys, so no augmentation override is needed. Mirror of the 3D +# er/fcmae_vscyto3d_pretrained/a549_mantis fit leaf. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + train_set: a549_mantis + model_name: fcmae_vscyto2d_pretrained + experiment_id: er__a549_mantis__fcmae_vscyto2d_pretrained + +model: + init_args: + # Load only the encoder from the 2D FCMAE ckpt (400 ep on HEK + A549 + + # BJ5a + LIVECell + CTMC phase data); decoder/head stay at fresh init. + # lr 0.0002 overrides the overlay's 0.0004 for pretrained finetuning. + encoder_only: true + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/fcmae-2d/pretrain-logs/hek-a549-bj5a-livecell-ctmc-400ep/checkpoints/last.ckpt + lr: 0.0002 + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Pretrained_A549_SEC61B_ws8500 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto2d_pretrained + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto2d_pretrained/checkpoints + +data: + init_args: + # A549 pooled in-focus slab store + target_channel — no resolver in + # this train_set. + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all_focus.zarr + +launcher: + job_name: FCMAE_VSCyto2D_Pretrained_A549_SEC61B_ws8500 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto2d_pretrained + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..474069008 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: er trained on ipsc_confocal, +# tested on a549-mantis-sec61b-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_denv + model_name: fcmae_vscyto2d_pretrained + experiment_id: er__ipsc_confocal__fcmae_vscyto2d_pretrained__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_pretrained/checkpoints/epoch=9-step=4220-loss=0.530.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_SEC61B_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..fab32a33a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: er trained on ipsc_confocal, +# tested on a549-mantis-sec61b-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_mock + model_name: fcmae_vscyto2d_pretrained + experiment_id: er__ipsc_confocal__fcmae_vscyto2d_pretrained__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_pretrained/checkpoints/epoch=9-step=4220-loss=0.530.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_SEC61B_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..52247840c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: er trained on ipsc_confocal, +# tested on a549-mantis-sec61b-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_zikv + model_name: fcmae_vscyto2d_pretrained + experiment_id: er__ipsc_confocal__fcmae_vscyto2d_pretrained__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_pretrained/checkpoints/epoch=9-step=4220-loss=0.530.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_SEC61B_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..a8f51e5d4 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: er trained on ipsc_confocal, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_pretrained + experiment_id: er__ipsc_confocal__fcmae_vscyto2d_pretrained__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_pretrained/checkpoints/epoch=9-step=4220-loss=0.530.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_SEC61B_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/train.yml new file mode 100644 index 000000000..a842ab202 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/ipsc_confocal/train.yml @@ -0,0 +1,83 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) with FCMAE-2D +# pretrained encoder init on ER/SEC61B, in-focus 2D benchmark track, +# iPSC confocal (aics-hipsc). Paper key: VSCyto2D. Companion to +# fcmae_vscyto2d_scratch — the two leaves are identical except this one +# loads the 2D FCMAE encoder weights and drops lr to 0.0002 (mirroring +# cytoland VSCyto2D finetuning). +# +# The 3D ipsc leaf resolves data_path/source_channel/target_channel from +# the manifest via benchmark.dataset_ref, which points at the NON-focus +# SEC61B.zarr. The 2D track reads the offline 5-plane in-focus slab store +# SEC61B_focus.zarr instead, so the resolver is disabled here +# (dataset_ref: null) and the three data fields are declared inline — the +# resolver hook raises on any data.init_args field co-declared with a full +# dataset_ref. source_channel/target_channel reproduce the resolver's +# manifest output (Phase3D / Structure). target_channel "Structure" also +# matches the FCMAE-2D data overlay's default augmentation keys, so no +# augmentation override is needed. Mirror of the 3D +# er/fcmae_vscyto3d_pretrained/ipsc_confocal fit leaf. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + train_set: ipsc_confocal + model_name: fcmae_vscyto2d_pretrained + experiment_id: er__ipsc_confocal__fcmae_vscyto2d_pretrained + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered SEC61B.zarr. dataset_ref: null makes + # the compose hook a no-op so data fields can be declared inline. + dataset_ref: null + +data: + init_args: + # iPSC in-focus slab store + channels — resolver disabled above. + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B_focus.zarr + +model: + init_args: + # Load only the encoder from the 2D FCMAE ckpt (400 ep on HEK + A549 + + # BJ5a + LIVECell + CTMC phase data); decoder/head stay at fresh init. + # lr 0.0002 overrides the overlay's 0.0004 for pretrained finetuning. + encoder_only: true + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/fcmae-2d/pretrain-logs/hek-a549-bj5a-livecell-ctmc-400ep/checkpoints/last.ckpt + lr: 0.0002 + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Pretrained_iPSC_SEC61B_ws8500 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_pretrained + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_pretrained/checkpoints + +launcher: + job_name: FCMAE_VSCyto2D_Pretrained_SEC61B_ws8500 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_pretrained + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..a0d3204a3 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: er trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-sec61b-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_denv + model_name: fcmae_vscyto2d_pretrained + experiment_id: er__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto2d_pretrained/checkpoints/epoch=7-step=5216-loss=0.520.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_JOINT_SEC61B_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..1c7eb440f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: er trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-sec61b-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_mock + model_name: fcmae_vscyto2d_pretrained + experiment_id: er__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto2d_pretrained/checkpoints/epoch=7-step=5216-loss=0.520.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_JOINT_SEC61B_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..f381aa868 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: er trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-sec61b-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_zikv + model_name: fcmae_vscyto2d_pretrained + experiment_id: er__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto2d_pretrained/checkpoints/epoch=7-step=5216-loss=0.520.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_JOINT_SEC61B_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..0913c6777 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: er trained on joint_ipsc_confocal_a549_mantis, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_pretrained + experiment_id: er__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto2d_pretrained/checkpoints/epoch=7-step=5216-loss=0.520.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_JOINT_SEC61B_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_pretrained/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..44aebf5e1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,165 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) with FCMAE-2D +# pretrained encoder init on er (SEC61B) — joint +# ipsc_confocal + a549_mantis pooled, in-focus 2D benchmark track. +# Paper key: VSCyto2D. Companion to the fcmae_vscyto2d_scratch joint +# leaf — the two are identical except this one loads the 2D FCMAE +# encoder weights and drops lr to 0.0002 (mirroring cytoland VSCyto2D +# finetuning). Mirrors er/fcmae_vscyto2d_pretrained/ipsc_confocal on the +# joint train_set, flattened to the 2D focus-slab geometry. +# +# Joint leaf: BatchedConcatDataModule with two explicit HCSDataModule +# children (no benchmark.dataset_ref — joint leaves bypass the single- +# dataset resolver, so both child data_paths are the offline +# `_focus.zarr` slab stores directly). Only +# model_overlays/fcmae_vscyto2d_fit.yml is composed; the data block is +# authored inline because joint hparams live on the children. +# +# Topology: single-GPU (inherited from model_overlays/fcmae_vscyto2d_fit.yml +# single_gpu base). z_window_size=1 reads one in-focus plane per window; +# BatchedConcatDataModule does NOT divide batch_size by num_samples, so +# batch_size=4 * num_samples=4 = 16 GPU samples/step, matching the +# single-set 2D data overlay's effective 16. +base: + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + gene: SEC61B + target: er + target_id: er_sec61b + train_set: joint_ipsc_confocal_a549_mantis + model_name: fcmae_vscyto2d_pretrained + experiment_id: er__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained + +model: + init_args: + # Load only the encoder from the 2D FCMAE ckpt (400 ep on HEK + A549 + + # BJ5a + LIVECell + CTMC phase data); decoder/head stay at fresh init. + # lr 0.0002 overrides the overlay's 0.0004 for pretrained finetuning. + encoder_only: true + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/fcmae-2d/pretrain-logs/hek-a549-bj5a-livecell-ctmc-400ep/checkpoints/last.ckpt + lr: 0.0002 + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Pretrained_JOINT_SEC61B_ws8500 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto2d_pretrained + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto2d_pretrained/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Structure + z_window_size: 1 + # batch_size is NOT divided by num_samples in joint mode: 4 indices * + # num_samples=4 = 16 GPU samples per rank, matching the single-set 2D + # data overlay's effective 16. + batch_size: 4 + num_workers: 4 + yx_patch_size: [384, 384] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Structure] + level: fov_statistics + subtrahend: median + divisor: iqr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 600, 600] + num_samples: 4 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [0, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[1, 1], [0.5, 1.5], [0.5, 1.5]] + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 384, 384] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0, 0] + val_gpu_augmentations: + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 384, 384] + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc SEC61B in-focus slab + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B_focus.zarr + # a549_mantis — pooled SEC61B in-focus slab + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all_focus.zarr + +launcher: + job_name: FCMAE_VSCyto2D_Pretrained_JOINT_SEC61B_ws8500 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto2d_pretrained + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..be9df9607 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: er trained on a549_mantis, +# tested on a549-mantis-sec61b-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_denv + model_name: fcmae_vscyto2d_scratch + experiment_id: er__a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto2d_scratch/checkpoints/epoch=60-step=14030-loss=0.549.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_A549TR_SEC61B_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..19abd121f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: er trained on a549_mantis, +# tested on a549-mantis-sec61b-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_mock + model_name: fcmae_vscyto2d_scratch + experiment_id: er__a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto2d_scratch/checkpoints/epoch=60-step=14030-loss=0.549.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_A549TR_SEC61B_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..f721d84cd --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: er trained on a549_mantis, +# tested on a549-mantis-sec61b-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_zikv + model_name: fcmae_vscyto2d_scratch + experiment_id: er__a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto2d_scratch/checkpoints/epoch=60-step=14030-loss=0.549.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_A549TR_SEC61B_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..0678e2627 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: er trained on a549_mantis, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch + experiment_id: er__a549_mantis__fcmae_vscyto2d_scratch__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto2d_scratch/checkpoints/epoch=60-step=14030-loss=0.549.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_A549TR_SEC61B_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/train.yml new file mode 100644 index 000000000..0e65c0d34 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/a549_mantis/train.yml @@ -0,0 +1,64 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) random-init baseline +# on ER/SEC61B, in-focus 2D benchmark track, A549 mantis pooled +# (mock + DENV + ZIKV). Scratch control for the fcmae_vscyto2d_pretrained +# (VSCyto2D) counterpart — the two leaves are identical except this one +# does NOT load pretrained encoder weights. +# +# Reads the offline 5-plane in-focus slab store SEC61B_all_focus.zarr +# (extracted from the 3D SEC61B_all.zarr; z_window_size=1 emits one +# in-focus window per plane). Mirror of the 3D +# er/fcmae_vscyto3d_scratch/a549_mantis fit leaf. target_channel == +# "Structure" matches the FCMAE-2D data overlay's RandWeightedCropd keys, +# so no augmentation override is needed here. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + train_set: a549_mantis + model_name: fcmae_vscyto2d_scratch + experiment_id: er__a549_mantis__fcmae_vscyto2d_scratch + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Scratch_A549_SEC61B + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto2d_scratch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto2d_scratch/checkpoints + +data: + init_args: + # A549 pooled in-focus slab store + target_channel — no resolver in + # this train_set. + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all_focus.zarr + +launcher: + job_name: FCMAE_VSCyto2D_Scratch_A549_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto2d_scratch + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..d8f40fb88 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: er trained on ipsc_confocal, +# tested on a549-mantis-sec61b-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_denv + model_name: fcmae_vscyto2d_scratch + experiment_id: er__ipsc_confocal__fcmae_vscyto2d_scratch__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_scratch/checkpoints/epoch=14-step=6330-loss=0.552.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_SEC61B_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..1d1bc4ebb --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: er trained on ipsc_confocal, +# tested on a549-mantis-sec61b-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_mock + model_name: fcmae_vscyto2d_scratch + experiment_id: er__ipsc_confocal__fcmae_vscyto2d_scratch__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_scratch/checkpoints/epoch=14-step=6330-loss=0.552.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_SEC61B_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..53220dc83 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: er trained on ipsc_confocal, +# tested on a549-mantis-sec61b-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_zikv + model_name: fcmae_vscyto2d_scratch + experiment_id: er__ipsc_confocal__fcmae_vscyto2d_scratch__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_scratch/checkpoints/epoch=14-step=6330-loss=0.552.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_SEC61B_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..b06eed8b1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: er trained on ipsc_confocal, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch + experiment_id: er__ipsc_confocal__fcmae_vscyto2d_scratch__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_scratch/checkpoints/epoch=14-step=6330-loss=0.552.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_SEC61B_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml new file mode 100644 index 000000000..624f81d33 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml @@ -0,0 +1,72 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) random-init baseline +# on ER/SEC61B, in-focus 2D benchmark track, iPSC confocal. Scratch +# control for the fcmae_vscyto2d_pretrained (VSCyto2D) counterpart — the +# two leaves are identical except this one does NOT load pretrained encoder +# weights. Mirror of the 3D er/fcmae_vscyto3d_scratch/ipsc_confocal fit +# leaf. target_channel == "Structure" matches the FCMAE-2D data overlay's +# RandWeightedCropd keys, so no augmentation override is needed here. +# +# The 3D ipsc leaf resolves data_path/source_channel/target_channel from +# the manifest via benchmark.dataset_ref, which points at the NON-focus +# SEC61B.zarr. The 2D track reads the offline 5-plane in-focus slab store +# SEC61B_focus.zarr instead, so the resolver is disabled here +# (dataset_ref: null) and the three data fields are declared inline — +# the resolver hook raises on any data.init_args field co-declared with a +# full dataset_ref. source_channel/target_channel reproduce the resolver's +# manifest output (Phase3D / Structure). +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + train_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch + experiment_id: er__ipsc_confocal__fcmae_vscyto2d_scratch + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered SEC61B.zarr. dataset_ref: null makes + # the compose hook a no-op so data fields can be declared inline. + dataset_ref: null + +data: + init_args: + # iPSC in-focus slab store + channels — resolver disabled above. + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B_focus.zarr + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Scratch_iPSC_SEC61B + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_scratch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_scratch/checkpoints + +launcher: + job_name: FCMAE_VSCyto2D_Scratch_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_scratch + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..cc9e7fbec --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: er trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-sec61b-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_denv + model_name: fcmae_vscyto2d_scratch + experiment_id: er__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto2d_scratch/checkpoints/epoch=13-step=9128-loss=0.547.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_JOINT_SEC61B_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..0744f7c4f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: er trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-sec61b-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_mock + model_name: fcmae_vscyto2d_scratch + experiment_id: er__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto2d_scratch/checkpoints/epoch=13-step=9128-loss=0.547.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_JOINT_SEC61B_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..74274015f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: er trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-sec61b-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_zikv + model_name: fcmae_vscyto2d_scratch + experiment_id: er__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto2d_scratch/checkpoints/epoch=13-step=9128-loss=0.547.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_JOINT_SEC61B_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..1ee9e6059 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: er trained on joint_ipsc_confocal_a549_mantis, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch + experiment_id: er__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto2d_scratch/checkpoints/epoch=13-step=9128-loss=0.547.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_JOINT_SEC61B_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..6f636d93c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,150 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) random-init baseline +# on er (SEC61B), in-focus 2D benchmark track — joint ipsc_confocal + +# a549_mantis pooled. Scratch control for the fcmae_vscyto2d_pretrained +# (VSCyto2D) counterpart — the two leaves are identical except this one +# does NOT load pretrained encoder weights. Mirrors +# er/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml on the joint train_set +# and the 3D er/fcmae_vscyto3d_scratch/joint_* leaf. +# +# Joint leaf: BatchedConcatDataModule + two explicit HCSDataModule +# children; only model_overlays/fcmae_vscyto2d_fit.yml is composed (the +# data overlay is NOT — the data block is inlined via the &hcs_init_args +# anchor). Both children read the offline 5-plane in-focus slab stores +# (z_window_size=1). Single-GPU topology (from the 2D model overlay + +# hardware_gpu_any_long), so no DDP block. +base: + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + gene: SEC61B + target: er + target_id: er_sec61b + train_set: joint_ipsc_confocal_a549_mantis + model_name: fcmae_vscyto2d_scratch + experiment_id: er__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Scratch_JOINT_SEC61B + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto2d_scratch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto2d_scratch/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Structure + z_window_size: 1 + # Joint mode does not divide batch_size by num_samples, so 4 * 4 = 16 GPU + # samples per step matches the single-set 2D overlay's effective batch + # (batch_size 16). Halved from the 3D joint's 8 to fit the single-GPU + # 48 GB pool (a40|l40s|a6000) that the 2D track targets. + batch_size: 4 + num_workers: 4 + yx_patch_size: [384, 384] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Structure] + level: fov_statistics + subtrahend: median + divisor: iqr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 600, 600] + num_samples: 4 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [0, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[1, 1], [0.5, 1.5], [0.5, 1.5]] + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 384, 384] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0, 0] + val_gpu_augmentations: + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 384, 384] + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc SEC61B in-focus slab store + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B_focus.zarr + # a549_mantis — pooled SEC61B all-conditions in-focus slab store + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all_focus.zarr + +launcher: + job_name: FCMAE_VSCyto2D_Scratch_JOINT_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto2d_scratch + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..ff533c744 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,61 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: er trained on ipsc_confocal, +# tested on a549-mantis-sec61b-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# Sample-matched UNeXt2-2D ablation arm (fcmae_vscyto2d_scratch with the 3D fit's +# optimizer budget: 128 samples/step, warmup 8500, 3D cosine horizon); otherwise +# identical to the fcmae_vscyto2d_scratch leaf of the same name. +# ckpt_path is a PROVISIONAL pin: the fit is still running and save_top_k rotates +# files out. Submit with --ckpt best (uses only the parent dir), or re-bake after the +# fit completes (tools/bake_best_ckpt.py). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_denv + model_name: fcmae_vscyto2d_scratch_samplematched + experiment_id: er__ipsc_confocal__fcmae_vscyto2d_scratch_samplematched__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_scratch_samplematched/checkpoints/epoch=4-step=260-loss=0.749.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_SampleMatch_PRED_SEC61B_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..d0134b74b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,61 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: er trained on ipsc_confocal, +# tested on a549-mantis-sec61b-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# Sample-matched UNeXt2-2D ablation arm (fcmae_vscyto2d_scratch with the 3D fit's +# optimizer budget: 128 samples/step, warmup 8500, 3D cosine horizon); otherwise +# identical to the fcmae_vscyto2d_scratch leaf of the same name. +# ckpt_path is a PROVISIONAL pin: the fit is still running and save_top_k rotates +# files out. Submit with --ckpt best (uses only the parent dir), or re-bake after the +# fit completes (tools/bake_best_ckpt.py). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_mock + model_name: fcmae_vscyto2d_scratch_samplematched + experiment_id: er__ipsc_confocal__fcmae_vscyto2d_scratch_samplematched__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_scratch_samplematched/checkpoints/epoch=4-step=260-loss=0.749.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_SampleMatch_PRED_SEC61B_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..bc3785609 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,61 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: er trained on ipsc_confocal, +# tested on a549-mantis-sec61b-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# Sample-matched UNeXt2-2D ablation arm (fcmae_vscyto2d_scratch with the 3D fit's +# optimizer budget: 128 samples/step, warmup 8500, 3D cosine horizon); otherwise +# identical to the fcmae_vscyto2d_scratch leaf of the same name. +# ckpt_path is a PROVISIONAL pin: the fit is still running and save_top_k rotates +# files out. Submit with --ckpt best (uses only the parent dir), or re-bake after the +# fit completes (tools/bake_best_ckpt.py). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_zikv + model_name: fcmae_vscyto2d_scratch_samplematched + experiment_id: er__ipsc_confocal__fcmae_vscyto2d_scratch_samplematched__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_scratch_samplematched/checkpoints/epoch=4-step=260-loss=0.749.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_SampleMatch_PRED_SEC61B_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..6f714c1f3 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,61 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: er trained on ipsc_confocal, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# Sample-matched UNeXt2-2D ablation arm (fcmae_vscyto2d_scratch with the 3D fit's +# optimizer budget: 128 samples/step, warmup 8500, 3D cosine horizon); otherwise +# identical to the fcmae_vscyto2d_scratch leaf of the same name. +# ckpt_path is a PROVISIONAL pin: the fit is still running and save_top_k rotates +# files out. Submit with --ckpt best (uses only the parent dir), or re-bake after the +# fit completes (tools/bake_best_ckpt.py). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch_samplematched + experiment_id: er__ipsc_confocal__fcmae_vscyto2d_scratch_samplematched__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_scratch_samplematched/checkpoints/epoch=4-step=260-loss=0.749.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch_samplematched/ipsc/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_SampleMatch_PRED_SEC61B_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto2d_scratch_samplematched/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/train.yml new file mode 100644 index 000000000..014a9607c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/train.yml @@ -0,0 +1,86 @@ +# Sample-matched UNeXt2-2D ablation — ER (SEC61B), iPSC-trained. +# +# IDENTICAL to er/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml except the +# optimizer budget, copied from er/fcmae_vscyto3d_scratch (the 3D UNeXt2 it is +# compared against): +# - 4-GPU DDP x batch_size 32 per rank = 128 samples/step (was 1 GPU x 16) +# - warmup_steps 8500 (was 4000) +# - cosine horizon 52800 steps = the 3D fit's 200 epochs x 264 steps/epoch +# (WarmupCosine t_total = trainer.estimated_stepping_batches, capped here by +# max_steps; max_epochs is raised only so it never binds first) +# - validation + checkpoint cadence every 5 epochs x ~53 steps ~= 265 steps, +# matching the 3D fit's once per 264-step epoch +# The 2D baseline trained 84400 steps x 16 samples = 1.35M samples; the 3D fit +# 44089 steps x 128 = 5.6M (it stopped at epoch 167/200; the paper predicts from +# its epoch=122-step=32472 checkpoint). This arm sees 52800 x 128 = 6.8M. +# +# See nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/train.yml for the +# question this answers, why target planes are not matched, and why precision +# stays bf16-mixed rather than the 3D fit's 16-mixed. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../../../recipes/topology/ddp_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + train_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch_samplematched + experiment_id: er__ipsc_confocal__fcmae_vscyto2d_scratch_samplematched + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered SEC61B.zarr. dataset_ref: null makes + # the compose hook a no-op so data fields can be declared inline. + dataset_ref: null + +data: + init_args: + # Per rank; x 4 ranks = 128 samples/step, the 3D fit's global batch. + batch_size: 32 + # iPSC in-focus slab store + channels — resolver disabled above. + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B_focus.zarr + +model: + init_args: + warmup_steps: 8500 + +trainer: + strategy: + class_path: lightning.pytorch.strategies.DDPStrategy + init_args: + find_unused_parameters: true + timeout: "3:00:00" + max_steps: 52800 + max_epochs: 2000 + check_val_every_n_epoch: 5 + logger: + init_args: + name: FCMAE_VSCyto2D_Scratch_SampleMatch_iPSC_SEC61B + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_scratch_samplematched + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 5 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_scratch_samplematched/checkpoints + +launcher: + job_name: FCMAE_VSCyto2D_Scratch_SampleMatch_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto2d_scratch_samplematched + # Same 128G as the 2D baseline (focus-store mmap buffer is ~5-11 GiB). + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_denv.yml index 8a55a1256..dd388b8fa 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_denv.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/er_sec61b.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_mock.yml index af265a180..489b37214 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_mock.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/er_sec61b.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_zikv.yml index f65dfacf3..cf0303891 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_zikv.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/er_sec61b.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__ipsc_confocal.yml index 8974b693c..d11e9ca9d 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__ipsc_confocal.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/er_sec61b.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml index ec7a7f60b..1488d7811 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml @@ -21,7 +21,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/sec61b/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=132-step=22876.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=106-step=18404.ckpt data: init_args: @@ -38,8 +38,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained_a549trained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B_A549TR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..7e2c49ae9 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_denv_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: er__a549_mantis__fcmae_vscyto3d_pretrained__a549_mantis_sec61b_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=106-step=18404.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B_A549TR_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml index 0944b8208..93cbcaa0e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml @@ -21,7 +21,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/sec61b/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=132-step=22876.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=106-step=18404.ckpt data: init_args: @@ -38,8 +38,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained_a549trained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B_A549TR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..e945bd466 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_mock_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: er__a549_mantis__fcmae_vscyto3d_pretrained__a549_mantis_sec61b_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=106-step=18404.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B_A549TR_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml index 36c7bbd0c..66974b746 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml @@ -21,7 +21,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/sec61b/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=132-step=22876.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=106-step=18404.ckpt data: init_args: @@ -38,8 +38,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained_a549trained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B_A549TR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..aadd16116 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_zikv_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: er__a549_mantis__fcmae_vscyto3d_pretrained__a549_mantis_sec61b_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=106-step=18404.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B_A549TR_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml index 54a35eec3..994f75cf1 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml @@ -19,7 +19,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/sec61b/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=132-step=22876.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=106-step=18404.ckpt data: init_args: @@ -36,8 +36,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_fcmae_vscyto3d_pretrained_a549trained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B_A549TR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..7d00bf228 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: ipsc_confocal_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: er__a549_mantis__fcmae_vscyto3d_pretrained__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=106-step=18404.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B_A549TR_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/train.yml index c58b0ecd5..fd25398f6 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/a549_mantis/train.yml @@ -31,7 +31,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Pretrained_A549_SEC61B_ws8500 - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/sec61b/fcmae_vscyto3d_pretrained_ws8500 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_pretrained callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -39,17 +39,19 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/sec61b/fcmae_vscyto3d_pretrained_ws8500/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_pretrained/checkpoints data: init_args: # A549 pooled store + target_channel — no resolver in this train_set. target_channel: Structure - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/SEC61B_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_A549_SEC61B_ws8500 - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/sec61b/fcmae_vscyto3d_pretrained_ws8500 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_pretrained diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index b432a9581..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by FCMAE_VSCyto3D_Pretrained on a549-mantis-sec61b-denv. -defaults: - - override /target: er_sec61b - - override /predict_set: a549_mantis_sec61b_denv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained__sec61b_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_sec61b_fcmae_vscyto3d_pretrained__sec61b_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index 583b37267..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by FCMAE_VSCyto3D_Pretrained on a549-mantis-sec61b-mock. -defaults: - - override /target: er_sec61b - - override /predict_set: a549_mantis_sec61b_mock - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained__sec61b_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_sec61b_fcmae_vscyto3d_pretrained__sec61b_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index a1a8e80f6..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by FCMAE_VSCyto3D_Pretrained on a549-mantis-sec61b-zikv. -defaults: - - override /target: er_sec61b - - override /predict_set: a549_mantis_sec61b_zikv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained__sec61b_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_sec61b_fcmae_vscyto3d_pretrained__sec61b_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml index 03dbbb139..b40582d4e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml @@ -26,7 +26,7 @@ model: # ep 123 / val_loss 0.40979 (49-epoch plateau, scancelled at 3d 1h elapsed). # Hardlink alias at run_root; the underlying checkpoints/epoch=123-step=32736.ckpt # is also preserved in checkpoints_frozen_ep123_20260501_004946/. - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fcmae_vscyto3d_pretrained_ws8500/best_ep123_val0.40979.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=123-step=32736.ckpt data: init_args: @@ -43,8 +43,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained__sec61b_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B_ON_A549_sec61b_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..cba2ef597 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_denv_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: er__ipsc_confocal__fcmae_vscyto3d_pretrained__a549_mantis_sec61b_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=123-step=32736.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B_ON_A549_sec61b_denv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml index 7136cb42b..b8394b1d5 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml @@ -26,7 +26,7 @@ model: # ep 123 / val_loss 0.40979 (49-epoch plateau, scancelled at 3d 1h elapsed). # Hardlink alias at run_root; the underlying checkpoints/epoch=123-step=32736.ckpt # is also preserved in checkpoints_frozen_ep123_20260501_004946/. - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fcmae_vscyto3d_pretrained_ws8500/best_ep123_val0.40979.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=123-step=32736.ckpt data: init_args: @@ -43,8 +43,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained__sec61b_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B_ON_A549_sec61b_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..0001665ed --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_mock_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: er__ipsc_confocal__fcmae_vscyto3d_pretrained__a549_mantis_sec61b_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=123-step=32736.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B_ON_A549_sec61b_mock_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml index 190b1d90e..3447d5ddc 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -26,7 +26,7 @@ model: # ep 123 / val_loss 0.40979 (49-epoch plateau, scancelled at 3d 1h elapsed). # Hardlink alias at run_root; the underlying checkpoints/epoch=123-step=32736.ckpt # is also preserved in checkpoints_frozen_ep123_20260501_004946/. - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fcmae_vscyto3d_pretrained_ws8500/best_ep123_val0.40979.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=123-step=32736.ckpt data: init_args: @@ -43,8 +43,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained__sec61b_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B_ON_A549_sec61b_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..e3f66f0c2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_zikv_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: er__ipsc_confocal__fcmae_vscyto3d_pretrained__a549_mantis_sec61b_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=123-step=32736.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B_ON_A549_sec61b_zikv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml index 920b3dfce..ded5ddd88 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml @@ -25,7 +25,7 @@ model: # ep 123 / val_loss 0.40979 (49-epoch plateau, scancelled at 3d 1h elapsed). # Hardlink alias at run_root; the underlying checkpoints/epoch=123-step=32736.ckpt # is also preserved in checkpoints_frozen_ep123_20260501_004946/. - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fcmae_vscyto3d_pretrained_ws8500/best_ep123_val0.40979.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=123-step=32736.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_fcmae_vscyto3d_pretrained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..16c20679e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: er__ipsc_confocal__fcmae_vscyto3d_pretrained__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=123-step=32736.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_pretrained/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/train.yml index d8e03ca03..25af8ab46 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/ipsc_confocal/train.yml @@ -31,7 +31,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Pretrained_iPSC_SEC61B_ws8500 - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fcmae_vscyto3d_pretrained_ws8500 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_pretrained callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -39,11 +39,13 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fcmae_vscyto3d_pretrained_ws8500/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_pretrained/checkpoints launcher: job_name: FCMAE_VSCyto3D_Pretrained_SEC61B_ws8500 - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fcmae_vscyto3d_pretrained_ws8500 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_pretrained diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index ad3322f0c..b38162a2a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=111-step=48496.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=162-step=70579-loss=0.411.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained_jointtrained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B_JOINTTR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index 53e93b9ee..2e961c842 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=111-step=48496.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=162-step=70579-loss=0.411.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained_jointtrained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B_JOINTTR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index 3eb7bd188..4e97b0c22 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=111-step=48496.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=162-step=70579-loss=0.411.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_pretrained_jointtrained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B_JOINTTR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index 1135ec504..16d0b60b7 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -27,7 +27,7 @@ model: # ckpt lives under the _ws8500 training-output subdir; config namespace # uses fcmae_vscyto3d_pretrained (no _ws8500 suffix) for consistency with # iPSC + a549 single-set predict configs. - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=111-step=48496.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto3d_pretrained/checkpoints/epoch=162-step=70579-loss=0.411.ckpt data: init_args: @@ -44,8 +44,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_fcmae_vscyto3d_pretrained_jointtrained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_SEC61B_JOINTTR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_pretrained/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml index 44acd7050..b77440721 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml @@ -22,7 +22,7 @@ base: - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_fit.yml - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu_long.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -46,7 +46,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Pretrained_JOINT_SEC61B_ws8500 - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fcmae_vscyto3d_pretrained_ws8500 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto3d_pretrained callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -54,10 +54,12 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fcmae_vscyto3d_pretrained_ws8500/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto3d_pretrained/checkpoints _hcs_init_args: &hcs_init_args source_channel: Phase3D @@ -147,8 +149,8 @@ data: - class_path: viscy_data.hcs.HCSDataModule init_args: <<: *hcs_init_args - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/SEC61B_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_JOINT_SEC61B_ws8500 - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fcmae_vscyto3d_pretrained_ws8500 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto3d_pretrained diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml index 782bf876b..5dd1ca5e8 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/sec61b/fcmae_vscyto3d_scratch/checkpoints/epoch=137-step=23736.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_scratch/checkpoints/epoch=132-step=22876.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch_a549trained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B_A549TR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..0ac7ded4a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_denv_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: er__a549_mantis__fcmae_vscyto3d_scratch__a549_mantis_sec61b_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_scratch/checkpoints/epoch=132-step=22876.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B_A549TR_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml index c165bf89b..64aad270b 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/sec61b/fcmae_vscyto3d_scratch/checkpoints/epoch=137-step=23736.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_scratch/checkpoints/epoch=132-step=22876.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch_a549trained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B_A549TR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..d82b6f045 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_mock_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: er__a549_mantis__fcmae_vscyto3d_scratch__a549_mantis_sec61b_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_scratch/checkpoints/epoch=132-step=22876.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B_A549TR_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml index 2b9e69980..30aefca64 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/sec61b/fcmae_vscyto3d_scratch/checkpoints/epoch=137-step=23736.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_scratch/checkpoints/epoch=132-step=22876.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch_a549trained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B_A549TR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..13689f470 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_zikv_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: er__a549_mantis__fcmae_vscyto3d_scratch__a549_mantis_sec61b_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_scratch/checkpoints/epoch=132-step=22876.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B_A549TR_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml index 5ab5951ce..7afa908c6 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml @@ -26,7 +26,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/sec61b/fcmae_vscyto3d_scratch/checkpoints/epoch=137-step=23736.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_scratch/checkpoints/epoch=132-step=22876.ckpt data: init_args: @@ -43,8 +43,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_fcmae_vscyto3d_scratch_a549trained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B_A549TR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..64e0621b4 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: ipsc_confocal_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: er__a549_mantis__fcmae_vscyto3d_scratch__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_scratch/checkpoints/epoch=132-step=22876.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B_A549TR_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/train.yml index fde2e8c5d..122b3bff3 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/a549_mantis/train.yml @@ -23,7 +23,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Scratch_A549_SEC61B - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/sec61b/fcmae_vscyto3d_scratch + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_scratch callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -31,17 +31,19 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/sec61b/fcmae_vscyto3d_scratch/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_scratch/checkpoints data: init_args: # A549 pooled store + target_channel — no resolver in this train_set. target_channel: Structure - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/SEC61B_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_A549_SEC61B - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/sec61b/fcmae_vscyto3d_scratch + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fcmae_vscyto3d_scratch diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index d1a899b82..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by FCMAE_VSCyto3D_Scratch on a549-mantis-sec61b-denv. -defaults: - - override /target: er_sec61b - - override /predict_set: a549_mantis_sec61b_denv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch__sec61b_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_sec61b_fcmae_vscyto3d_scratch__sec61b_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index 0f6d13412..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by FCMAE_VSCyto3D_Scratch on a549-mantis-sec61b-mock. -defaults: - - override /target: er_sec61b - - override /predict_set: a549_mantis_sec61b_mock - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch__sec61b_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_sec61b_fcmae_vscyto3d_scratch__sec61b_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index 99f56a7fd..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by FCMAE_VSCyto3D_Scratch on a549-mantis-sec61b-zikv. -defaults: - - override /target: er_sec61b - - override /predict_set: a549_mantis_sec61b_zikv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch__sec61b_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_sec61b_fcmae_vscyto3d_scratch__sec61b_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml index 3eb26f308..b0a8ce7a2 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fcmae_vscyto3d_scratch/checkpoints/epoch=122-step=32472.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_scratch/checkpoints/epoch=122-step=32472.ckpt data: init_args: @@ -40,8 +40,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch__sec61b_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B_ON_A549_sec61b_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..c552db441 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_denv_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: er__ipsc_confocal__fcmae_vscyto3d_scratch__a549_mantis_sec61b_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_scratch/checkpoints/epoch=122-step=32472.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B_ON_A549_sec61b_denv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml index e8564d6a1..55e84d0dd 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fcmae_vscyto3d_scratch/checkpoints/epoch=122-step=32472.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_scratch/checkpoints/epoch=122-step=32472.ckpt data: init_args: @@ -40,8 +40,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch__sec61b_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B_ON_A549_sec61b_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..a47e0f53a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_mock_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: er__ipsc_confocal__fcmae_vscyto3d_scratch__a549_mantis_sec61b_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_scratch/checkpoints/epoch=122-step=32472.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B_ON_A549_sec61b_mock_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml index 5a0ab3eab..4c64ca160 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fcmae_vscyto3d_scratch/checkpoints/epoch=122-step=32472.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_scratch/checkpoints/epoch=122-step=32472.ckpt data: init_args: @@ -40,8 +40,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch__sec61b_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B_ON_A549_sec61b_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..9590932fe --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_zikv_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: er__ipsc_confocal__fcmae_vscyto3d_scratch__a549_mantis_sec61b_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_scratch/checkpoints/epoch=122-step=32472.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B_ON_A549_sec61b_zikv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml index bd862f614..410087aba 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fcmae_vscyto3d_scratch/checkpoints/epoch=122-step=32472.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_scratch/checkpoints/epoch=122-step=32472.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_fcmae_vscyto3d_scratch.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..a7360cacf --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: er__ipsc_confocal__fcmae_vscyto3d_scratch__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_scratch/checkpoints/epoch=122-step=32472.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fcmae_vscyto3d_scratch/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/train.yml index f3f1cbe31..30bf4f66f 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/ipsc_confocal/train.yml @@ -23,7 +23,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Scratch_iPSC_SEC61B - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fcmae_vscyto3d_scratch + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_scratch callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -31,11 +31,13 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fcmae_vscyto3d_scratch/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_scratch/checkpoints launcher: job_name: FCMAE_VSCyto3D_Scratch_SEC61B - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fcmae_vscyto3d_scratch + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fcmae_vscyto3d_scratch diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index 8518bc2b6..8983c9c3a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fcmae_vscyto3d_scratch/checkpoints/epoch=75-step=32908.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto3d_scratch/checkpoints/epoch=115-step=50228-loss=0.417.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch_jointtrained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B_JOINTTR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index 5db0b78a8..3ef426d5a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fcmae_vscyto3d_scratch/checkpoints/epoch=75-step=32908.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto3d_scratch/checkpoints/epoch=115-step=50228-loss=0.417.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch_jointtrained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B_JOINTTR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index d8ff2a643..c36bc430b 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fcmae_vscyto3d_scratch/checkpoints/epoch=75-step=32908.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto3d_scratch/checkpoints/epoch=115-step=50228-loss=0.417.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fcmae_vscyto3d_scratch_jointtrained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B_JOINTTR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index 2cbb9e39f..7c0c84f2d 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fcmae_vscyto3d_scratch/checkpoints/epoch=75-step=32908.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto3d_scratch/checkpoints/epoch=115-step=50228-loss=0.417.ckpt data: init_args: @@ -40,8 +40,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_fcmae_vscyto3d_scratch_jointtrained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_SEC61B_JOINTTR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fcmae_vscyto3d_scratch/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/train.yml index 282b99377..5fa66e7f4 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/train.yml @@ -17,7 +17,7 @@ base: - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_fit.yml - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu_long.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -34,7 +34,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Scratch_JOINT_SEC61B - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fcmae_vscyto3d_scratch + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto3d_scratch callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -42,10 +42,12 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fcmae_vscyto3d_scratch/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto3d_scratch/checkpoints _hcs_init_args: &hcs_init_args source_channel: Phase3D @@ -135,8 +137,8 @@ data: - class_path: viscy_data.hcs.HCSDataModule init_args: <<: *hcs_init_args - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/SEC61B_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_JOINT_SEC61B - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fcmae_vscyto3d_scratch + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fcmae_vscyto3d_scratch diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..2951e7419 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,52 @@ +# FNet2D predict: er (SEC61B) trained on a549_mantis, tested on A549 mantis denv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=920-step=147360-loss=0.865.ckpt (loss/validate=0.865). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_denv + model_name: fnet2d + experiment_id: er__a549_mantis__fnet2d__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet2d/checkpoints/epoch=920-step=147360-loss=0.865.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/a549__denv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_SEC61B_A549TR_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..d9826f093 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,52 @@ +# FNet2D predict: er (SEC61B) trained on a549_mantis, tested on A549 mantis mock. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=920-step=147360-loss=0.865.ckpt (loss/validate=0.865). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_mock + model_name: fnet2d + experiment_id: er__a549_mantis__fnet2d__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet2d/checkpoints/epoch=920-step=147360-loss=0.865.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/a549__mock/prediction.zarr + +launcher: + job_name: FNet2D_PRED_SEC61B_A549TR_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..ccc4a034b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,52 @@ +# FNet2D predict: er (SEC61B) trained on a549_mantis, tested on A549 mantis zikv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=920-step=147360-loss=0.865.ckpt (loss/validate=0.865). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_zikv + model_name: fnet2d + experiment_id: er__a549_mantis__fnet2d__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet2d/checkpoints/epoch=920-step=147360-loss=0.865.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/a549__zikv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_SEC61B_A549TR_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..831efcdcd --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,52 @@ +# FNet2D predict: er (SEC61B) trained on a549_mantis, tested on iPSC confocal. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=920-step=147360-loss=0.865.ckpt (loss/validate=0.865). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: fnet2d + experiment_id: er__a549_mantis__fnet2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet2d/checkpoints/epoch=920-step=147360-loss=0.865.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/ipsc/prediction.zarr + +launcher: + job_name: FNet2D_PRED_SEC61B_A549TR + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/train.yml new file mode 100644 index 000000000..7db4dac0c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/a549_mantis/train.yml @@ -0,0 +1,56 @@ +# FNet2D (FNet3D run Z-preserving at Z=1) fit on ER (SEC61B marker) — A549 +# mantis-lightsheet pooled (mock + DENV + ZIKV), in-focus 2D track. Mirror of +# the 3D er/fnet3d_paper/a549_mantis fit leaf, flattened onto the offline +# 5-plane in-focus slab store SEC61B_all_focus.zarr (z_window_size=1 emits one +# in-focus window per plane). target_channel == Structure, so the fnet2d data +# overlay's default norms/augs (already [1,64,64]) apply unchanged. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/data_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + train_set: a549_mantis + model_name: fnet2d + experiment_id: er__a549_mantis__fnet2d + +trainer: + logger: + init_args: + name: FNet2D_A549_SEC61B + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet2d/checkpoints + +data: + init_args: + # A549 pooled in-focus slab store + target_channel — no resolver in this + # train_set. + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all_focus.zarr + +launcher: + job_name: FNet2D_A549_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet2d + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D store + # (~1/4 the Z), so the 512G headroom the 3D leaf needed for mmap_preload + # is wasteful and delays scheduling. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..6073e2ee1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,52 @@ +# FNet2D predict: er (SEC61B) trained on ipsc_confocal, tested on A549 mantis denv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=668-step=187989-loss=0.911.ckpt (loss/validate=0.911). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_denv + model_name: fnet2d + experiment_id: er__ipsc_confocal__fnet2d__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet2d/checkpoints/epoch=668-step=187989-loss=0.911.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_SEC61B_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..2f15c955a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,52 @@ +# FNet2D predict: er (SEC61B) trained on ipsc_confocal, tested on A549 mantis mock. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=668-step=187989-loss=0.911.ckpt (loss/validate=0.911). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_mock + model_name: fnet2d + experiment_id: er__ipsc_confocal__fnet2d__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet2d/checkpoints/epoch=668-step=187989-loss=0.911.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: FNet2D_PRED_SEC61B_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..157da3024 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,52 @@ +# FNet2D predict: er (SEC61B) trained on ipsc_confocal, tested on A549 mantis zikv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=668-step=187989-loss=0.911.ckpt (loss/validate=0.911). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_zikv + model_name: fnet2d + experiment_id: er__ipsc_confocal__fnet2d__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet2d/checkpoints/epoch=668-step=187989-loss=0.911.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_SEC61B_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..708b673e3 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,52 @@ +# FNet2D predict: er (SEC61B) trained on ipsc_confocal, tested on iPSC confocal. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=668-step=187989-loss=0.911.ckpt (loss/validate=0.911). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fnet2d + experiment_id: er__ipsc_confocal__fnet2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet2d/checkpoints/epoch=668-step=187989-loss=0.911.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/ipsc/prediction.zarr + +launcher: + job_name: FNet2D_PRED_SEC61B + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/train.yml new file mode 100644 index 000000000..7a76f0886 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/ipsc_confocal/train.yml @@ -0,0 +1,63 @@ +# FNet2D (FNet3D run Z-preserving at Z=1) fit on ER (SEC61B marker) — AICS +# iPSC confocal, in-focus 2D track. Mirror of the 3D +# er/fnet3d_paper/ipsc_confocal fit leaf, flattened onto the offline 5-plane +# in-focus slab store SEC61B_focus.zarr (z_window_size=1 emits one in-focus +# window per plane). target_channel == Structure, so the fnet2d data overlay's +# default norms/augs (already [1,64,64]) apply unchanged. +# +# The 3D ipsc leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus +# SEC61B.zarr. The 2D track reads SEC61B_focus.zarr instead, so the resolver +# is disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field co-declared +# with a full dataset_ref. source_channel/target_channel reproduce the +# resolver's manifest output (Phase3D / Structure). +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/data_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + train_set: ipsc_confocal + model_name: fnet2d + experiment_id: er__ipsc_confocal__fnet2d + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered SEC61B.zarr. dataset_ref: null makes + # the compose hook a no-op so data fields can be declared inline. + dataset_ref: null + +data: + init_args: + # iPSC in-focus slab store + channels — resolver disabled above. + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B_focus.zarr + +trainer: + logger: + init_args: + name: FNet2D_iPSC_SEC61B + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet2d/checkpoints + +launcher: + job_name: FNet2D_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet2d diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..a4bcefc96 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,52 @@ +# FNet2D predict: er (SEC61B) trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis denv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=180-step=78735-loss=1.090.ckpt (loss/validate=1.090). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_denv + model_name: fnet2d + experiment_id: er__joint_ipsc_confocal_a549_mantis__fnet2d__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fnet2d/checkpoints/epoch=180-step=78735-loss=1.090.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/a549__denv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_SEC61B_JOINTTR_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..c65d6b6f6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,52 @@ +# FNet2D predict: er (SEC61B) trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis mock. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=180-step=78735-loss=1.090.ckpt (loss/validate=1.090). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_mock + model_name: fnet2d + experiment_id: er__joint_ipsc_confocal_a549_mantis__fnet2d__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fnet2d/checkpoints/epoch=180-step=78735-loss=1.090.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/a549__mock/prediction.zarr + +launcher: + job_name: FNet2D_PRED_SEC61B_JOINTTR_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..69703ca83 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,52 @@ +# FNet2D predict: er (SEC61B) trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis zikv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=180-step=78735-loss=1.090.ckpt (loss/validate=1.090). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_zikv + model_name: fnet2d + experiment_id: er__joint_ipsc_confocal_a549_mantis__fnet2d__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fnet2d/checkpoints/epoch=180-step=78735-loss=1.090.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/a549__zikv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_SEC61B_JOINTTR_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..097ea33c1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,52 @@ +# FNet2D predict: er (SEC61B) trained on joint_ipsc_confocal_a549_mantis, tested on iPSC confocal. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=180-step=78735-loss=1.090.ckpt (loss/validate=1.090). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: fnet2d + experiment_id: er__joint_ipsc_confocal_a549_mantis__fnet2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fnet2d/checkpoints/epoch=180-step=78735-loss=1.090.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/ipsc/prediction.zarr + +launcher: + job_name: FNet2D_PRED_SEC61B_JOINTTR + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..a453d191a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,123 @@ +# FNet2D (FNet3D run Z-preserving at Z=1) fit on er (SEC61B) — joint +# ipsc_confocal + a549_mantis pooled, in-focus 2D track. Mirror of the 3D +# er/fnet3d_paper/joint_* fit leaf, flattened onto the offline 5-plane +# in-focus slab stores (z_window_size=1 emits one in-focus window per plane). +# +# BatchedConcatDataModule + two explicit HCSDataModule children; only +# model_overlays/fnet2d_fit.yml is composed (the data block is authored +# inline here, not via data_overlays). Norms + 8-crops-per-FOV diverge from +# the CellDiff/UNetViT conventions: target channel uses mean/std (not +# median/iqr) and val augmentations are CPU CenterSpatialCropd on the raw +# keys. Crops flattened [32,64,64] -> [1,64,64], z_window_size 32 -> 1. +# +# Topology: single GPU, any model, long wall — same as the 3D FNet paper +# baseline, kept so iPSC-only and joint runs are apples-to-apples. +base: + - ../../../_internal/shared/model/model_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + gene: SEC61B + target: er + target_id: er_sec61b + train_set: joint_ipsc_confocal_a549_mantis + model_name: fnet2d + experiment_id: er__joint_ipsc_confocal_a549_mantis__fnet2d + +trainer: + logger: + init_args: + name: FNet2D_JOINT_SEC61B + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fnet2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fnet2d/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Structure + z_window_size: 1 + # See nucleus/fnet2d/joint_*/train.yml for the rationale: joint mode does + # not divide batch_size by num_samples (unlike single-set), so + # 6 * num_samples=8 = 48 GPU samples matches single-set effective. + batch_size: 6 + num_workers: 8 + yx_patch_size: [64, 64] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Structure] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 64, 64] + num_samples: 8 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandFlipd + init_args: + keys: [source, target] + spatial_axes: [1] + prob: 0.5 + - class_path: viscy_transforms.BatchedRandFlipd + init_args: + keys: [source, target] + spatial_axes: [2] + prob: 0.5 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Phase3D, Structure] + roi_size: [1, 64, 64] + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc SEC61B in-focus slab store + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B_focus.zarr + # a549_mantis — pooled SEC61B in-focus slab store + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all_focus.zarr + +launcher: + job_name: FNet2D_JOINT_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fnet2d + # 128G: the in-focus slab stores are 5-plane slices of the full-Z 3D + # stores (~1/4 the Z), so the 512G headroom the 3D joint leaf needed for + # dual mmap_preload is wasteful and delays scheduling. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..c88fcd1eb --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,52 @@ +# FNet2D voxel-matched predict: er (SEC61B) trained on ipsc_confocal, tested on A549 mantis denv. +# Voxel-matched FNet-2D ablation arm (batch 48 -> 1536 = fnet3d_paper's planes/step); +# otherwise identical to the fnet2d leaf of the same name, including the fnet2d_predict +# overlay (full-Z store, z_window_size=1) and Phase3D fov_statistics normalization. +# ckpt_path is a PROVISIONAL pin: the fit is still running and save_top_k rotates +# files out. Submit with --ckpt best (uses only the parent dir), or re-bake after the +# fit completes (tools/bake_best_ckpt.py). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_denv + model_name: fnet2d_voxelmatched + experiment_id: er__ipsc_confocal__fnet2d_voxelmatched__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet2d_voxelmatched/checkpoints/epoch=1049-step=8400-loss=0.883.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d_voxelmatched/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: FNet2DVoxMatch_PRED_SEC61B_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d_voxelmatched/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..8bf0bb098 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,52 @@ +# FNet2D voxel-matched predict: er (SEC61B) trained on ipsc_confocal, tested on A549 mantis mock. +# Voxel-matched FNet-2D ablation arm (batch 48 -> 1536 = fnet3d_paper's planes/step); +# otherwise identical to the fnet2d leaf of the same name, including the fnet2d_predict +# overlay (full-Z store, z_window_size=1) and Phase3D fov_statistics normalization. +# ckpt_path is a PROVISIONAL pin: the fit is still running and save_top_k rotates +# files out. Submit with --ckpt best (uses only the parent dir), or re-bake after the +# fit completes (tools/bake_best_ckpt.py). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_mock + model_name: fnet2d_voxelmatched + experiment_id: er__ipsc_confocal__fnet2d_voxelmatched__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet2d_voxelmatched/checkpoints/epoch=1049-step=8400-loss=0.883.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d_voxelmatched/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: FNet2DVoxMatch_PRED_SEC61B_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d_voxelmatched/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..e0ac11d22 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,52 @@ +# FNet2D voxel-matched predict: er (SEC61B) trained on ipsc_confocal, tested on A549 mantis zikv. +# Voxel-matched FNet-2D ablation arm (batch 48 -> 1536 = fnet3d_paper's planes/step); +# otherwise identical to the fnet2d leaf of the same name, including the fnet2d_predict +# overlay (full-Z store, z_window_size=1) and Phase3D fov_statistics normalization. +# ckpt_path is a PROVISIONAL pin: the fit is still running and save_top_k rotates +# files out. Submit with --ckpt best (uses only the parent dir), or re-bake after the +# fit completes (tools/bake_best_ckpt.py). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_zikv + model_name: fnet2d_voxelmatched + experiment_id: er__ipsc_confocal__fnet2d_voxelmatched__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet2d_voxelmatched/checkpoints/epoch=1049-step=8400-loss=0.883.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d_voxelmatched/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: FNet2DVoxMatch_PRED_SEC61B_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d_voxelmatched/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..6523a39cc --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,52 @@ +# FNet2D voxel-matched predict: er (SEC61B) trained on ipsc_confocal, tested on iPSC confocal. +# Voxel-matched FNet-2D ablation arm (batch 48 -> 1536 = fnet3d_paper's planes/step); +# otherwise identical to the fnet2d leaf of the same name, including the fnet2d_predict +# overlay (full-Z store, z_window_size=1) and Phase3D fov_statistics normalization. +# ckpt_path is a PROVISIONAL pin: the fit is still running and save_top_k rotates +# files out. Submit with --ckpt best (uses only the parent dir), or re-bake after the +# fit completes (tools/bake_best_ckpt.py). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fnet2d_voxelmatched + experiment_id: er__ipsc_confocal__fnet2d_voxelmatched__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet2d_voxelmatched/checkpoints/epoch=1049-step=8400-loss=0.883.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d_voxelmatched/ipsc/ipsc/prediction.zarr + +launcher: + job_name: FNet2DVoxMatch_PRED_SEC61B + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet2d_voxelmatched/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/train.yml new file mode 100644 index 000000000..824fd7288 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet2d_voxelmatched/ipsc_confocal/train.yml @@ -0,0 +1,67 @@ +# Voxel-matched FNet-2D ablation — ER (SEC61B), iPSC-trained. +# +# IDENTICAL to er/fnet2d/ipsc_confocal/train.yml except batch_size +# 48 -> 1536 (and the run name/paths). fnet2d and fnet3d_paper already match on +# optimizer steps (max_steps 200000), samples/step (48), 64x64 XY patch, flip-only +# augs, lr, loss and fp32 — but fnet3d_paper's samples are 32 planes deep, so it +# supervises 48 x 32 = 1536 target planes per step against fnet2d's 48. +# 1536 = 48 x 32 closes that 32x gap. num_samples stays 8 (same crop sampler), +# so each step draws 1536 / 8 = 192 single-plane windows. +# +# Question it answers: does 3D beat 2D on the budget-matched FNet pair because of +# z-CONTEXT, or because it saw 32x more supervised voxels? If this arm closes the +# gap to fnet3d_paper, it was supervision; if it stays at fnet2d, it was context. +# Caveat: a 32x larger batch at the same constant lr also changes the optimizer's +# gradient noise, so this is a voxel-matched arm, not a pure-supervision control. +# +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/data_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + train_set: ipsc_confocal + model_name: fnet2d_voxelmatched + experiment_id: er__ipsc_confocal__fnet2d_voxelmatched + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered SEC61B.zarr. dataset_ref: null makes + # the compose hook a no-op so data fields can be declared inline. + dataset_ref: null + +data: + init_args: + # 48 x 32 — voxel parity with fnet3d_paper (see header). + batch_size: 1536 + # iPSC in-focus slab store + channels — resolver disabled above. + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B_focus.zarr + +trainer: + logger: + init_args: + name: FNet2D_VoxMatch_iPSC_SEC61B + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet2d_voxelmatched + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet2d_voxelmatched/checkpoints + +launcher: + job_name: FNet2DVoxMatch_iPSC_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet2d_voxelmatched diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..a90217e45 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,41 @@ +# fnet3d_paper predict: er (SEC61B) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_denv + model_name: fnet3d_paper + experiment_id: er__a549_mantis__fnet3d_paper__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_paper/checkpoints/epoch=350-step=185679.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/a549__denv/prediction.zarr + +launcher: + job_name: FNet3DPaper_PRED_SEC61B_A549TR_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..4a1fa8bee --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_denv_lite + model_name: fnet3d_paper + experiment_id: er__a549_mantis__fnet3d_paper__a549_mantis_sec61b_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_paper/checkpoints/epoch=350-step=185679.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/a549/a549__denv/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_SEC61B_A549TR_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..49e916c54 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,41 @@ +# fnet3d_paper predict: er (SEC61B) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_mock + model_name: fnet3d_paper + experiment_id: er__a549_mantis__fnet3d_paper__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_paper/checkpoints/epoch=350-step=185679.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/a549__mock/prediction.zarr + +launcher: + job_name: FNet3DPaper_PRED_SEC61B_A549TR_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..a62f14f9c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_mock_lite + model_name: fnet3d_paper + experiment_id: er__a549_mantis__fnet3d_paper__a549_mantis_sec61b_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_paper/checkpoints/epoch=350-step=185679.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/a549/a549__mock/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_SEC61B_A549TR_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..6720dfa6e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,41 @@ +# fnet3d_paper predict: er (SEC61B) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_zikv + model_name: fnet3d_paper + experiment_id: er__a549_mantis__fnet3d_paper__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_paper/checkpoints/epoch=350-step=185679.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/a549__zikv/prediction.zarr + +launcher: + job_name: FNet3DPaper_PRED_SEC61B_A549TR_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..22f3445e5 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_zikv_lite + model_name: fnet3d_paper + experiment_id: er__a549_mantis__fnet3d_paper__a549_mantis_sec61b_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_paper/checkpoints/epoch=350-step=185679.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/a549/a549__zikv/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_SEC61B_A549TR_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..19a589189 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,41 @@ +# fnet3d_paper predict: er (SEC61B) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: fnet3d_paper + experiment_id: er__a549_mantis__fnet3d_paper__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_paper/checkpoints/epoch=350-step=185679.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/ipsc/prediction.zarr + +launcher: + job_name: FNet3DPaper_PRED_SEC61B_A549TR_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..c9ec37333 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: ipsc_confocal_lite + model_name: fnet3d_paper + experiment_id: er__a549_mantis__fnet3d_paper__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_paper/checkpoints/epoch=350-step=185679.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/a549/ipsc/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_SEC61B_A549TR_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/train.yml index 1b822de85..f9faa7e23 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis/train.yml @@ -21,7 +21,7 @@ trainer: logger: init_args: name: FNet3D_A549_SEC61B_paper - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/sec61b/fnet3d_paper + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_paper callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -29,20 +29,22 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/sec61b/fnet3d_paper/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_paper/checkpoints data: init_args: # A549 pooled store + target_channel — no resolver in this train_set. target_channel: Structure - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/SEC61B_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all.zarr launcher: job_name: FNet3DPaper_A549_SEC61B - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/sec61b/fnet3d_paper + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_paper # 512G to match the shared headroom convention across the fnet3d # leaves on a549/joint workloads. mmap_preload after the BasicIndexer # fix peaks at ~75 GB for SEC61B_all alone (single-set); 512G gives diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..7b23c685a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_denv.yml @@ -0,0 +1,60 @@ +# FNet3DPaperBF predict: er trained on a549_mantis_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_sec61b_denv. +# +# Brightfield-input ablation arm of +# er/fnet3d_paper/a549_mantis/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `a549__bf`). +# +# Checkpoint is the loss/validate-monitored best: 0.5071, at parity with the +# phase baseline's 0.5045 (epoch 350). Read from the monitored ModelCheckpoint +# callback in last.ckpt -- that file also carries an unmonitored `latest-*` +# callback whose best_model_path is just the final step. +# +# A549 manifest keys er by gene (`sec61b`); override the iPSC-side +# `er` target_id from targets/er_sec61b.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis_brightfield + predict_set: a549_mantis_sec61b_denv + model_name: fnet3d_paper + experiment_id: er__a549_mantis_brightfield__fnet3d_paper__a549_mantis_sec61b_denv + dataset_ref: + source_channel: Brightfield + target: sec61b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/er/fnet3d_paper/checkpoints/epoch=371-step=196788-loss=0.507.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549__bf/a549__denv/prediction.zarr + +launcher: + job_name: FNet3DPaperBF_PRED_SEC61B_A549TR_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549__bf/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..0d31ccc5e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_mock.yml @@ -0,0 +1,60 @@ +# FNet3DPaperBF predict: er trained on a549_mantis_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_sec61b_mock. +# +# Brightfield-input ablation arm of +# er/fnet3d_paper/a549_mantis/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `a549__bf`). +# +# Checkpoint is the loss/validate-monitored best: 0.5071, at parity with the +# phase baseline's 0.5045 (epoch 350). Read from the monitored ModelCheckpoint +# callback in last.ckpt -- that file also carries an unmonitored `latest-*` +# callback whose best_model_path is just the final step. +# +# A549 manifest keys er by gene (`sec61b`); override the iPSC-side +# `er` target_id from targets/er_sec61b.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis_brightfield + predict_set: a549_mantis_sec61b_mock + model_name: fnet3d_paper + experiment_id: er__a549_mantis_brightfield__fnet3d_paper__a549_mantis_sec61b_mock + dataset_ref: + source_channel: Brightfield + target: sec61b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/er/fnet3d_paper/checkpoints/epoch=371-step=196788-loss=0.507.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549__bf/a549__mock/prediction.zarr + +launcher: + job_name: FNet3DPaperBF_PRED_SEC61B_A549TR_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549__bf/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..dc8ec47eb --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_zikv.yml @@ -0,0 +1,60 @@ +# FNet3DPaperBF predict: er trained on a549_mantis_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_sec61b_zikv. +# +# Brightfield-input ablation arm of +# er/fnet3d_paper/a549_mantis/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `a549__bf`). +# +# Checkpoint is the loss/validate-monitored best: 0.5071, at parity with the +# phase baseline's 0.5045 (epoch 350). Read from the monitored ModelCheckpoint +# callback in last.ckpt -- that file also carries an unmonitored `latest-*` +# callback whose best_model_path is just the final step. +# +# A549 manifest keys er by gene (`sec61b`); override the iPSC-side +# `er` target_id from targets/er_sec61b.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis_brightfield + predict_set: a549_mantis_sec61b_zikv + model_name: fnet3d_paper + experiment_id: er__a549_mantis_brightfield__fnet3d_paper__a549_mantis_sec61b_zikv + dataset_ref: + source_channel: Brightfield + target: sec61b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/er/fnet3d_paper/checkpoints/epoch=371-step=196788-loss=0.507.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549__bf/a549__zikv/prediction.zarr + +launcher: + job_name: FNet3DPaperBF_PRED_SEC61B_A549TR_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549__bf/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/predict__ipsc_confocal.yml new file mode 100644 index 000000000..a1eed4e2f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/predict__ipsc_confocal.yml @@ -0,0 +1,56 @@ +# FNet3DPaperBF predict: er trained on a549_mantis_brightfield, BRIGHTFIELD input, +# predicting against ipsc_confocal. +# +# Brightfield-input ablation arm of +# er/fnet3d_paper/a549_mantis/predict__ipsc*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `a549__bf`). +# +# Checkpoint is the loss/validate-monitored best: 0.5071, at parity with the +# phase baseline's 0.5045 (epoch 350). Read from the monitored ModelCheckpoint +# callback in last.ckpt -- that file also carries an unmonitored `latest-*` +# callback whose best_model_path is just the final step. + +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis_brightfield + predict_set: ipsc_confocal + model_name: fnet3d_paper + experiment_id: er__a549_mantis_brightfield__fnet3d_paper__ipsc_confocal + dataset_ref: + source_channel: Brightfield + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/er/fnet3d_paper/checkpoints/epoch=371-step=196788-loss=0.507.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549__bf/ipsc/prediction.zarr + +launcher: + job_name: FNet3DPaperBF_PRED_SEC61B_A549TR_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/a549__bf/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/train.yml new file mode 100644 index 000000000..6a7a1f744 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/a549_mantis_brightfield/train.yml @@ -0,0 +1,89 @@ +# FNet3D paper-baseline fit on ER (SEC61B marker) — A549 mantis-lightsheet pooled, BRIGHTFIELD input. +# +# Brightfield-input ablation arm of er/fnet3d_paper/a549_mantis/train.yml. Every +# hyperparameter is identical to that baseline; the only change is the model input +# channel (Brightfield instead of the Phase3D volume reconstructed from it), which +# enters via train_sets/a549_mantis_brightfield.yml's source_channel. +# +# ⚠ The baseline authors NO transform lists — it inherits them from +# targets/er_sec61b.yml as replaced by data_overlays/fnet3d_paper_fit.yml, which +# composes later and wins. So the live values are Structure mean/std, 32x64x64 and +# num_samples 8 -- NOT the target fragment's median/iqr, 13x624x624 and 2. The lists +# below are copied from that composed result; re-deriving them from the target +# fragment would silently change three hyperparameters. +# +# The pooled store also carries `Structure_deconvolved`; the target is the raw +# `Structure`, matching the baseline (the deconv token is retired). +base: + - ../../../_internal/shared/model/train_sets/a549_mantis_brightfield.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/data_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + train_set: a549_mantis_brightfield + model_name: fnet3d_paper + experiment_id: er__a549_mantis_brightfield__fnet3d_paper + +data: + init_args: + # A549 pooled store + target_channel — no resolver in this train_set. + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all.zarr + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Structure] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Brightfield, Structure] + w_key: Structure + spatial_size: [32, 64, 64] + num_samples: 8 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Brightfield, Structure] + roi_size: [32, 64, 64] + +trainer: + logger: + init_args: + name: FNet3D_A549bf_SEC61B_paper + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/er/fnet3d_paper + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/er/fnet3d_paper/checkpoints + +launcher: + job_name: FNet3DPaperBF_A549_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/er/fnet3d_paper + # 512G carried over from the phase baseline (mmap_preload peaks at + # ~75 GB for SEC61B_all alone; the shared fnet3d a549/joint convention). + sbatch: + mem: "512G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index 8c7725382..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by FNet3DPaper on a549-mantis-sec61b-denv. -defaults: - - override /target: er_sec61b - - override /predict_set: a549_mantis_sec61b_denv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fnet3d_paper__sec61b_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_sec61b_fnet3d_paper__sec61b_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index b1459e28e..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by FNet3DPaper on a549-mantis-sec61b-mock. -defaults: - - override /target: er_sec61b - - override /predict_set: a549_mantis_sec61b_mock - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fnet3d_paper__sec61b_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_sec61b_fnet3d_paper__sec61b_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index c8d2dae45..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by FNet3DPaper on a549-mantis-sec61b-zikv. -defaults: - - override /target: er_sec61b - - override /predict_set: a549_mantis_sec61b_zikv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fnet3d_paper__sec61b_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_sec61b_fnet3d_paper__sec61b_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml index 522703d7e..1d4605f21 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml @@ -18,7 +18,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fnet3d_paper/checkpoints/epoch=183-step=134688.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet3d_paper/checkpoints/epoch=183-step=134688.ckpt data: init_args: @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fnet3d_paper__sec61b_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/a549__denv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_SEC61B_ON_A549_sec61b_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..c472e6023 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_denv_lite + model_name: fnet3d_paper + experiment_id: er__ipsc_confocal__fnet3d_paper__a549_mantis_sec61b_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet3d_paper/checkpoints/epoch=183-step=134688.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/ipsc/a549__denv/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_SEC61B_ON_A549_sec61b_denv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml index 01ba6b1b8..95425a4a4 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml @@ -18,7 +18,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fnet3d_paper/checkpoints/epoch=183-step=134688.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet3d_paper/checkpoints/epoch=183-step=134688.ckpt data: init_args: @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fnet3d_paper__sec61b_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/a549__mock/prediction.zarr launcher: job_name: FNet3DPaper_PRED_SEC61B_ON_A549_sec61b_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..59ca0698f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_mock_lite + model_name: fnet3d_paper + experiment_id: er__ipsc_confocal__fnet3d_paper__a549_mantis_sec61b_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet3d_paper/checkpoints/epoch=183-step=134688.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/ipsc/a549__mock/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_SEC61B_ON_A549_sec61b_mock_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml index e56f920d4..968e3b9a3 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -18,7 +18,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fnet3d_paper/checkpoints/epoch=183-step=134688.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet3d_paper/checkpoints/epoch=183-step=134688.ckpt data: init_args: @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fnet3d_paper__sec61b_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/a549__zikv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_SEC61B_ON_A549_sec61b_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..8fea8c0b1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_zikv_lite + model_name: fnet3d_paper + experiment_id: er__ipsc_confocal__fnet3d_paper__a549_mantis_sec61b_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet3d_paper/checkpoints/epoch=183-step=134688.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_SEC61B_ON_A549_sec61b_zikv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml index e38bd6fde..42249d34b 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml @@ -18,7 +18,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fnet3d_paper/checkpoints/epoch=183-step=134688.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet3d_paper/checkpoints/epoch=183-step=134688.ckpt data: init_args: @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_fnet3d_paper.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/ipsc/prediction.zarr launcher: job_name: FNet3DPaper_PRED_SEC61B - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..e9e808417 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: fnet3d_paper + experiment_id: er__ipsc_confocal__fnet3d_paper__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet3d_paper/checkpoints/epoch=183-step=134688.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/ipsc/ipsc/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_SEC61B_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/fnet3d_paper/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/train.yml index 3d55701de..bb54119b8 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal/train.yml @@ -21,7 +21,7 @@ trainer: logger: init_args: name: FNet3D_iPSC_SEC61B_paper - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fnet3d_paper + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet3d_paper callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -29,11 +29,13 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fnet3d_paper/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet3d_paper/checkpoints launcher: job_name: FNet3DPaper_SEC61B - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/sec61b/fnet3d_paper + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/fnet3d_paper diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..0c3dc0d37 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml @@ -0,0 +1,60 @@ +# FNet3DPaperBF predict: er trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_sec61b_denv. +# +# Brightfield-input ablation arm of +# er/fnet3d_paper/ipsc_confocal/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `ipsc__bf`). +# +# Checkpoint is the loss/validate-monitored best: 0.5222, better than the +# phase baseline's 0.5991 (epoch 183). Read from the monitored ModelCheckpoint +# callback in last.ckpt -- that file also carries an unmonitored `latest-*` +# callback whose best_model_path is just the final step. +# +# A549 manifest keys er by gene (`sec61b`); override the iPSC-side +# `er` target_id from targets/er_sec61b.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal_brightfield + predict_set: a549_mantis_sec61b_denv + model_name: fnet3d_paper + experiment_id: er__ipsc_confocal_brightfield__fnet3d_paper__a549_mantis_sec61b_denv + dataset_ref: + source_channel: Brightfield + target: sec61b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/er/fnet3d_paper/checkpoints/epoch=244-step=179340-loss=0.522.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc__bf/a549__denv/prediction.zarr + +launcher: + job_name: FNet3DPaperBF_PRED_SEC61B_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc__bf/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..5b6330f47 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml @@ -0,0 +1,60 @@ +# FNet3DPaperBF predict: er trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_sec61b_mock. +# +# Brightfield-input ablation arm of +# er/fnet3d_paper/ipsc_confocal/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `ipsc__bf`). +# +# Checkpoint is the loss/validate-monitored best: 0.5222, better than the +# phase baseline's 0.5991 (epoch 183). Read from the monitored ModelCheckpoint +# callback in last.ckpt -- that file also carries an unmonitored `latest-*` +# callback whose best_model_path is just the final step. +# +# A549 manifest keys er by gene (`sec61b`); override the iPSC-side +# `er` target_id from targets/er_sec61b.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal_brightfield + predict_set: a549_mantis_sec61b_mock + model_name: fnet3d_paper + experiment_id: er__ipsc_confocal_brightfield__fnet3d_paper__a549_mantis_sec61b_mock + dataset_ref: + source_channel: Brightfield + target: sec61b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/er/fnet3d_paper/checkpoints/epoch=244-step=179340-loss=0.522.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc__bf/a549__mock/prediction.zarr + +launcher: + job_name: FNet3DPaperBF_PRED_SEC61B_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc__bf/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..fa40db541 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml @@ -0,0 +1,60 @@ +# FNet3DPaperBF predict: er trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_sec61b_zikv. +# +# Brightfield-input ablation arm of +# er/fnet3d_paper/ipsc_confocal/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `ipsc__bf`). +# +# Checkpoint is the loss/validate-monitored best: 0.5222, better than the +# phase baseline's 0.5991 (epoch 183). Read from the monitored ModelCheckpoint +# callback in last.ckpt -- that file also carries an unmonitored `latest-*` +# callback whose best_model_path is just the final step. +# +# A549 manifest keys er by gene (`sec61b`); override the iPSC-side +# `er` target_id from targets/er_sec61b.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal_brightfield + predict_set: a549_mantis_sec61b_zikv + model_name: fnet3d_paper + experiment_id: er__ipsc_confocal_brightfield__fnet3d_paper__a549_mantis_sec61b_zikv + dataset_ref: + source_channel: Brightfield + target: sec61b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/er/fnet3d_paper/checkpoints/epoch=244-step=179340-loss=0.522.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc__bf/a549__zikv/prediction.zarr + +launcher: + job_name: FNet3DPaperBF_PRED_SEC61B_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc__bf/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/predict__ipsc_confocal.yml new file mode 100644 index 000000000..9e33cb7fa --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/predict__ipsc_confocal.yml @@ -0,0 +1,56 @@ +# FNet3DPaperBF predict: er trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against ipsc_confocal. +# +# Brightfield-input ablation arm of +# er/fnet3d_paper/ipsc_confocal/predict__ipsc*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `ipsc__bf`). +# +# Checkpoint is the loss/validate-monitored best: 0.5222, better than the +# phase baseline's 0.5991 (epoch 183). Read from the monitored ModelCheckpoint +# callback in last.ckpt -- that file also carries an unmonitored `latest-*` +# callback whose best_model_path is just the final step. + +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal_brightfield + predict_set: ipsc_confocal + model_name: fnet3d_paper + experiment_id: er__ipsc_confocal_brightfield__fnet3d_paper__ipsc_confocal + dataset_ref: + source_channel: Brightfield + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/er/fnet3d_paper/checkpoints/epoch=244-step=179340-loss=0.522.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc__bf/ipsc/prediction.zarr + +launcher: + job_name: FNet3DPaperBF_PRED_SEC61B + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/ipsc__bf/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/train.yml new file mode 100644 index 000000000..f6c74bf2b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/ipsc_confocal_brightfield/train.yml @@ -0,0 +1,79 @@ +# FNet3D paper-baseline fit on ER (SEC61B marker) — AICS iPSC confocal, BRIGHTFIELD input. +# +# Brightfield-input ablation arm of er/fnet3d_paper/ipsc_confocal/train.yml. Every +# hyperparameter is identical to that baseline; the only change is the model input +# channel (Brightfield instead of the Phase3D volume reconstructed from it), which +# enters via train_sets/ipsc_confocal_brightfield.yml's dataset_ref.source_channel. +# +# ⚠ The three lists below are copied from the COMPOSED baseline, not from +# targets/er_sec61b.yml. data_overlays/fnet3d_paper_fit.yml composes after the target +# fragment and replaces all three lists wholesale, so the live values differ from the +# target's on three axes: Structure is mean/std (not median/iqr), crops are 32x64x64 +# (not 13x624x624), and num_samples is 8 (not 2). Re-deriving these from the target +# fragment would silently change three hyperparameters and invalidate the comparison. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal_brightfield.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/data_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + train_set: ipsc_confocal_brightfield + model_name: fnet3d_paper + experiment_id: er__ipsc_confocal_brightfield__fnet3d_paper + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Structure] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Brightfield, Structure] + w_key: Structure + spatial_size: [32, 64, 64] + num_samples: 8 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Brightfield, Structure] + roi_size: [32, 64, 64] + +trainer: + logger: + init_args: + name: FNet3D_iPSCbf_SEC61B_paper + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/er/fnet3d_paper + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/er/fnet3d_paper/checkpoints + +launcher: + job_name: FNet3DPaperBF_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/er/fnet3d_paper diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index e9b0a04a0..3b0d2f818 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fnet3d_paper/checkpoints/epoch=106-step=135034.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fnet3d_paper/checkpoints/epoch=125-step=159012.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fnet3d_paper_jointtrained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/a549__denv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_SEC61B_JOINTTR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index 7034a56b9..5badff8de 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fnet3d_paper/checkpoints/epoch=106-step=135034.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fnet3d_paper/checkpoints/epoch=125-step=159012.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fnet3d_paper_jointtrained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/a549__mock/prediction.zarr launcher: job_name: FNet3DPaper_PRED_SEC61B_JOINTTR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index fb03c0e95..8679b3807 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fnet3d_paper/checkpoints/epoch=106-step=135034.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fnet3d_paper/checkpoints/epoch=125-step=159012.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_fnet3d_paper_jointtrained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/a549__zikv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_SEC61B_JOINTTR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index b3129cf8e..e2d200be8 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fnet3d_paper/checkpoints/epoch=106-step=135034.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fnet3d_paper/checkpoints/epoch=125-step=159012.ckpt data: init_args: @@ -40,8 +40,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_fnet3d_paper_jointtrained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/ipsc/prediction.zarr launcher: job_name: FNet3DPaper_PRED_SEC61B_JOINTTR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_paper/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/train.yml index b430d6771..09178ff4b 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_paper/joint_ipsc_confocal_a549_mantis/train.yml @@ -34,7 +34,7 @@ trainer: logger: init_args: name: FNet3D_JOINT_SEC61B_paper - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fnet3d_paper + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fnet3d_paper callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -42,10 +42,12 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fnet3d_paper/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fnet3d_paper/checkpoints _hcs_init_args: &hcs_init_args source_channel: Phase3D @@ -111,11 +113,11 @@ data: - class_path: viscy_data.hcs.HCSDataModule init_args: <<: *hcs_init_args - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/SEC61B_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all.zarr launcher: job_name: FNet3DPaper_JOINT_SEC61B - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/fnet3d_paper + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/fnet3d_paper # Joint preloads two stores (iPSC + A549 pool) into /dev/shm; the default # 256G cap is too tight (256G iPSC mem + ~50G A549 + worker peak OOMs). # 512G is the smallest tier that fits joint preload + worker overhead. diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/predict__a549_mantis_sec61b_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/predict__a549_mantis_sec61b_denv.yml new file mode 100644 index 000000000..252afc4fa --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/predict__a549_mantis_sec61b_denv.yml @@ -0,0 +1,57 @@ +# FNet3D temporal-sampling ablation (Phase 17) predict: er arm `fnet3d_t01` +# trained on a549_mantis, predicting a549-mantis-sec61b-denv. +# +# This arm trained on timepoints {0,1} only (hpi 5 and 7), at the +# same frame budget as its partner. The A549 test set spans hpi 5->23, so it is the +# shared yardstick: the two arms validate on DIFFERENT frames (each on its own subset +# store), which makes `loss/validate` incomparable across arms. These predicts are the +# only valid cross-arm comparison. +# +# The pinned `ckpt_path` below is PROVISIONAL -- the best-by-monitor checkpoint as of +# 2026-07-30 11:00, while the fit is still running. Submit with `--ckpt best`, which +# takes only the parent directory from this path and re-resolves `best_model_path` +# from the newest `last*.ckpt` at submit time. `save_top_k: 4` may well have rotated +# this exact file away by then; that is expected and harmless. +# NEVER pin `last.ckpt`: these arms' val curves are noisy (epoch IQR 0.066-0.237, +# larger than the whole second-half trend), so `last` lands at an arbitrary point in +# the jitter -- nucleus/fnet3d_t01's `last` was val 0.166 against a best of 0.078. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_denv + model_name: fnet3d_t01 + experiment_id: er__a549_mantis__fnet3d_t01__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_t01/checkpoints/epoch=599-step=74400-loss=0.747.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_t01/a549/a549__denv/prediction.zarr + +launcher: + job_name: FNet3DT01_PRED_SEC61B_A549TR_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_t01/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/predict__a549_mantis_sec61b_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/predict__a549_mantis_sec61b_mock.yml new file mode 100644 index 000000000..930ee4548 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/predict__a549_mantis_sec61b_mock.yml @@ -0,0 +1,57 @@ +# FNet3D temporal-sampling ablation (Phase 17) predict: er arm `fnet3d_t01` +# trained on a549_mantis, predicting a549-mantis-sec61b-mock. +# +# This arm trained on timepoints {0,1} only (hpi 5 and 7), at the +# same frame budget as its partner. The A549 test set spans hpi 5->23, so it is the +# shared yardstick: the two arms validate on DIFFERENT frames (each on its own subset +# store), which makes `loss/validate` incomparable across arms. These predicts are the +# only valid cross-arm comparison. +# +# The pinned `ckpt_path` below is PROVISIONAL -- the best-by-monitor checkpoint as of +# 2026-07-30 11:00, while the fit is still running. Submit with `--ckpt best`, which +# takes only the parent directory from this path and re-resolves `best_model_path` +# from the newest `last*.ckpt` at submit time. `save_top_k: 4` may well have rotated +# this exact file away by then; that is expected and harmless. +# NEVER pin `last.ckpt`: these arms' val curves are noisy (epoch IQR 0.066-0.237, +# larger than the whole second-half trend), so `last` lands at an arbitrary point in +# the jitter -- nucleus/fnet3d_t01's `last` was val 0.166 against a best of 0.078. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_mock + model_name: fnet3d_t01 + experiment_id: er__a549_mantis__fnet3d_t01__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_t01/checkpoints/epoch=599-step=74400-loss=0.747.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_t01/a549/a549__mock/prediction.zarr + +launcher: + job_name: FNet3DT01_PRED_SEC61B_A549TR_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_t01/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/predict__a549_mantis_sec61b_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/predict__a549_mantis_sec61b_zikv.yml new file mode 100644 index 000000000..217df5d69 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/predict__a549_mantis_sec61b_zikv.yml @@ -0,0 +1,57 @@ +# FNet3D temporal-sampling ablation (Phase 17) predict: er arm `fnet3d_t01` +# trained on a549_mantis, predicting a549-mantis-sec61b-zikv. +# +# This arm trained on timepoints {0,1} only (hpi 5 and 7), at the +# same frame budget as its partner. The A549 test set spans hpi 5->23, so it is the +# shared yardstick: the two arms validate on DIFFERENT frames (each on its own subset +# store), which makes `loss/validate` incomparable across arms. These predicts are the +# only valid cross-arm comparison. +# +# The pinned `ckpt_path` below is PROVISIONAL -- the best-by-monitor checkpoint as of +# 2026-07-30 11:00, while the fit is still running. Submit with `--ckpt best`, which +# takes only the parent directory from this path and re-resolves `best_model_path` +# from the newest `last*.ckpt` at submit time. `save_top_k: 4` may well have rotated +# this exact file away by then; that is expected and harmless. +# NEVER pin `last.ckpt`: these arms' val curves are noisy (epoch IQR 0.066-0.237, +# larger than the whole second-half trend), so `last` lands at an arbitrary point in +# the jitter -- nucleus/fnet3d_t01's `last` was val 0.166 against a best of 0.078. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_zikv + model_name: fnet3d_t01 + experiment_id: er__a549_mantis__fnet3d_t01__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_t01/checkpoints/epoch=599-step=74400-loss=0.747.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_t01/a549/a549__zikv/prediction.zarr + +launcher: + job_name: FNet3DT01_PRED_SEC61B_A549TR_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_t01/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/train.yml new file mode 100644 index 000000000..286b36cb0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/train.yml @@ -0,0 +1,77 @@ +# FNet3D temporal-sampling ablation, Arm A "early window" (Phase 17) — ER (SEC61B). +# +# Identical to er/fnet3d_paper/a549_mantis/train.yml except `data_path`: this arm +# reads SEC61B_t01.zarr, the timepoint-subset store holding timepoints {0, 1} of +# every position — hpi 5 and 7, a two-hour window at the start of infection. Its +# partner `fnet3d_tspread` reads the same number of frames spread over each +# position's whole range, so the pair isolates temporal diversity at a fixed frame +# budget. The full-time-course fnet3d_paper fit is the third rung (the ceiling). +# +# Built by tools/build_temporal_subset_zarr.py --mode early --n-timepoints 2 from +# the RAW `mantis/train/` store (A549 ER targets are raw GFP there; the deconvolved +# channel lives alongside as Structure_deconvolved and is not copied). +# 28 positions x 2 frames -> 22 train / 6 val positions (split_ratio 0.8), 44 train +# and 12 val (position, timepoint) pairs. Half the ER positions have only 7 source +# frames (5->15 hpi), which constrains the partner arm's spread, not this one. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/data_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + train_set: a549_mantis + model_name: fnet3d_t01 + experiment_id: er__a549_mantis__fnet3d_t01 + +data: + init_args: + # A549 pooled store + target_channel — no resolver in this train_set. + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_t01.zarr + +trainer: + logger: + init_args: + name: FNet3D_A549_SEC61B_t01 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_t01 + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + # 1/5 the frames means ~1/5 the steps per epoch (748 windows / 6 windows per + # step = 124 steps/epoch, so max_steps 200000 is ~1600 epochs). At + # every_n_epochs 1 that is ~1600 write-then-delete cycles of a 424 MB + # checkpoint, and long fnet/fcmae runs have silently stopped writing + # checkpoints three times now. Validation still runs every epoch. + every_n_epochs: 10 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_t01/checkpoints + +launcher: + job_name: FNet3DT01_A549_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_t01 + sbatch: + # The fnet3d_paper a549 leaf asks for 512G because staging the FULL pooled store + # peaks ~75 GB; this arm stages 56 frames x 2 channels (~13 GB), so 96G is + # generous. 16 CPUs covers num_workers 8 with persistent workers. Both cuts + # matter for scheduling, not for results. + # + # Constrained OFF the >=80 GB pool (a100_80/h100_80/h200) on purpose: the + # concurrent re-eval campaign needs those cards for cold deep-feature + # extraction, and this fit does not — the paper baseline trained the same + # patch/batch/precision on an A6000. + constraint: "a6000|a40|l40s" + cpus_per_task: 16 + mem: "96G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/train_smoke.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/train_smoke.yml new file mode 100644 index 000000000..a83c5480c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_t01/a549_mantis/train_smoke.yml @@ -0,0 +1,43 @@ +# Smoke sibling of er/fnet3d_t01/a549_mantis/train.yml. +# The ER counterpart of the nucleus smoke, and not redundant with it: SEC61B_t01.zarr +# is a MIXED-length plate (half its source positions have 7 frames, half 10), it +# carries the raw `Structure` target rather than `Nuclei`, and its per-FOV window +# count therefore comes out of a different branch of the subset builder. Checks the +# same things: subset `fov_statistics` survived, mmap_preload stages the store, +# RandWeightedCropd finds foreground in 2 frames per FOV, train + val MSE finite. +# Scratch run_root, no logger, no checkpoints, 30 steps, bounded 40-min wall. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/data_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + train_set: a549_mantis + model_name: fnet3d_t01 + experiment_id: er__a549_mantis__fnet3d_t01__smoke + +trainer: + max_steps: 30 + limit_val_batches: 2 + logger: false + callbacks: [] + +data: + init_args: + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_t01.zarr + +launcher: + job_name: FNet3DT01_SEC61B_SMOKE + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/_smoke/fnet3d_t01_a549_er + sbatch: + constraint: "a6000|a40|l40s" + cpus_per_task: 16 + mem: "96G" + time: "00:40:00" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_tspread/a549_mantis/predict__a549_mantis_sec61b_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_tspread/a549_mantis/predict__a549_mantis_sec61b_denv.yml new file mode 100644 index 000000000..ee5b8fbe0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_tspread/a549_mantis/predict__a549_mantis_sec61b_denv.yml @@ -0,0 +1,57 @@ +# FNet3D temporal-sampling ablation (Phase 17) predict: er arm `fnet3d_tspread` +# trained on a549_mantis, predicting a549-mantis-sec61b-denv. +# +# This arm trained on 2 timepoints spread across each position's full 5->23 hpi range, at the +# same frame budget as its partner. The A549 test set spans hpi 5->23, so it is the +# shared yardstick: the two arms validate on DIFFERENT frames (each on its own subset +# store), which makes `loss/validate` incomparable across arms. These predicts are the +# only valid cross-arm comparison. +# +# The pinned `ckpt_path` below is PROVISIONAL -- the best-by-monitor checkpoint as of +# 2026-07-30 11:00, while the fit is still running. Submit with `--ckpt best`, which +# takes only the parent directory from this path and re-resolves `best_model_path` +# from the newest `last*.ckpt` at submit time. `save_top_k: 4` may well have rotated +# this exact file away by then; that is expected and harmless. +# NEVER pin `last.ckpt`: these arms' val curves are noisy (epoch IQR 0.066-0.237, +# larger than the whole second-half trend), so `last` lands at an arbitrary point in +# the jitter -- nucleus/fnet3d_t01's `last` was val 0.166 against a best of 0.078. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_denv + model_name: fnet3d_tspread + experiment_id: er__a549_mantis__fnet3d_tspread__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_tspread/checkpoints/epoch=699-step=86800-loss=0.405.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_tspread/a549/a549__denv/prediction.zarr + +launcher: + job_name: FNet3DTSpread_PRED_SEC61B_A549TR_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_tspread/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_tspread/a549_mantis/predict__a549_mantis_sec61b_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_tspread/a549_mantis/predict__a549_mantis_sec61b_mock.yml new file mode 100644 index 000000000..aa74143b7 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_tspread/a549_mantis/predict__a549_mantis_sec61b_mock.yml @@ -0,0 +1,57 @@ +# FNet3D temporal-sampling ablation (Phase 17) predict: er arm `fnet3d_tspread` +# trained on a549_mantis, predicting a549-mantis-sec61b-mock. +# +# This arm trained on 2 timepoints spread across each position's full 5->23 hpi range, at the +# same frame budget as its partner. The A549 test set spans hpi 5->23, so it is the +# shared yardstick: the two arms validate on DIFFERENT frames (each on its own subset +# store), which makes `loss/validate` incomparable across arms. These predicts are the +# only valid cross-arm comparison. +# +# The pinned `ckpt_path` below is PROVISIONAL -- the best-by-monitor checkpoint as of +# 2026-07-30 11:00, while the fit is still running. Submit with `--ckpt best`, which +# takes only the parent directory from this path and re-resolves `best_model_path` +# from the newest `last*.ckpt` at submit time. `save_top_k: 4` may well have rotated +# this exact file away by then; that is expected and harmless. +# NEVER pin `last.ckpt`: these arms' val curves are noisy (epoch IQR 0.066-0.237, +# larger than the whole second-half trend), so `last` lands at an arbitrary point in +# the jitter -- nucleus/fnet3d_t01's `last` was val 0.166 against a best of 0.078. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_mock + model_name: fnet3d_tspread + experiment_id: er__a549_mantis__fnet3d_tspread__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_tspread/checkpoints/epoch=699-step=86800-loss=0.405.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_tspread/a549/a549__mock/prediction.zarr + +launcher: + job_name: FNet3DTSpread_PRED_SEC61B_A549TR_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_tspread/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_tspread/a549_mantis/predict__a549_mantis_sec61b_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_tspread/a549_mantis/predict__a549_mantis_sec61b_zikv.yml new file mode 100644 index 000000000..23d2090ef --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_tspread/a549_mantis/predict__a549_mantis_sec61b_zikv.yml @@ -0,0 +1,57 @@ +# FNet3D temporal-sampling ablation (Phase 17) predict: er arm `fnet3d_tspread` +# trained on a549_mantis, predicting a549-mantis-sec61b-zikv. +# +# This arm trained on 2 timepoints spread across each position's full 5->23 hpi range, at the +# same frame budget as its partner. The A549 test set spans hpi 5->23, so it is the +# shared yardstick: the two arms validate on DIFFERENT frames (each on its own subset +# store), which makes `loss/validate` incomparable across arms. These predicts are the +# only valid cross-arm comparison. +# +# The pinned `ckpt_path` below is PROVISIONAL -- the best-by-monitor checkpoint as of +# 2026-07-30 11:00, while the fit is still running. Submit with `--ckpt best`, which +# takes only the parent directory from this path and re-resolves `best_model_path` +# from the newest `last*.ckpt` at submit time. `save_top_k: 4` may well have rotated +# this exact file away by then; that is expected and harmless. +# NEVER pin `last.ckpt`: these arms' val curves are noisy (epoch IQR 0.066-0.237, +# larger than the whole second-half trend), so `last` lands at an arbitrary point in +# the jitter -- nucleus/fnet3d_t01's `last` was val 0.166 against a best of 0.078. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_zikv + model_name: fnet3d_tspread + experiment_id: er__a549_mantis__fnet3d_tspread__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_tspread/checkpoints/epoch=699-step=86800-loss=0.405.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_tspread/a549/a549__zikv/prediction.zarr + +launcher: + job_name: FNet3DTSpread_PRED_SEC61B_A549TR_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/fnet3d_tspread/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_tspread/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_tspread/a549_mantis/train.yml new file mode 100644 index 000000000..24ea6fb51 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/fnet3d_tspread/a549_mantis/train.yml @@ -0,0 +1,79 @@ +# FNet3D temporal-sampling ablation, Arm B "spread" (Phase 17) — ER (SEC61B). +# +# Identical to er/fnet3d_paper/a549_mantis/train.yml except `data_path`: this arm +# reads SEC61B_tspread.zarr, which holds 2 timepoints per position spread over that +# position's own range (plate ordinal i takes t = i % T and (i % T + T//2) % T — a +# 6 h separation on the 7-frame positions, 10 h on the 10-frame ones). Its partner +# `fnet3d_t01` reads the SAME number of frames from a two-hour early window (hpi 5 +# and 7), so the pair isolates temporal diversity at a fixed frame budget. The +# full-time-course fnet3d_paper fit is the third rung (the ceiling). +# +# Built by tools/build_temporal_subset_zarr.py --mode spread --n-timepoints 2 from +# the RAW `mantis/train/` store (A549 ER targets are raw GFP there; the deconvolved +# channel lives alongside as Structure_deconvolved and is not copied). +# 28 positions x 2 frames -> 22 train / 6 val positions (split_ratio 0.8), 44 train +# and 12 val (position, timepoint) pairs. Half the ER positions have only 7 source +# frames (5->15 hpi), so this arm spans less time on those than on the 10-frame ones, +# and its per-timepoint coverage is mildly uneven on the 10-frame group (2-4 of 28). +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/data_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + train_set: a549_mantis + model_name: fnet3d_tspread + experiment_id: er__a549_mantis__fnet3d_tspread + +data: + init_args: + # A549 pooled store + target_channel — no resolver in this train_set. + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_tspread.zarr + +trainer: + logger: + init_args: + name: FNet3D_A549_SEC61B_tspread + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_tspread + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + # 1/5 the frames means ~1/5 the steps per epoch (748 windows / 6 windows per + # step = 124 steps/epoch, so max_steps 200000 is ~1600 epochs). At + # every_n_epochs 1 that is ~1600 write-then-delete cycles of a 424 MB + # checkpoint, and long fnet/fcmae runs have silently stopped writing + # checkpoints three times now. Validation still runs every epoch. + every_n_epochs: 10 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_tspread/checkpoints + +launcher: + job_name: FNet3DTSpread_A549_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/fnet3d_tspread + sbatch: + # The fnet3d_paper a549 leaf asks for 512G because staging the FULL pooled store + # peaks ~75 GB; this arm stages 56 frames x 2 channels (~13 GB), so 96G is + # generous. 16 CPUs covers num_workers 8 with persistent workers. Both cuts + # matter for scheduling, not for results. + # + # Constrained OFF the >=80 GB pool (a100_80/h100_80/h200) on purpose: the + # concurrent re-eval campaign needs those cards for cold deep-feature + # extraction, and this fit does not — the paper baseline trained the same + # patch/batch/precision on an A6000. + constraint: "a6000|a40|l40s" + cpus_per_task: 16 + mem: "96G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..bac2c98af --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: er trained on a549_mantis, tested on A549 mantis denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/er_sec61b.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_denv + model_name: pix2pix2d_unetvit + experiment_id: er__a549_mantis__pix2pix2d_unetvit__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix2d_unetvit/checkpoints/epoch=35-step=8568-loss=0.726.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/a549__denv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_A549_SEC61B_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..f5d02a8f1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: er trained on a549_mantis, tested on A549 mantis mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/er_sec61b.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_mock + model_name: pix2pix2d_unetvit + experiment_id: er__a549_mantis__pix2pix2d_unetvit__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix2d_unetvit/checkpoints/epoch=35-step=8568-loss=0.726.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/a549__mock/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_A549_SEC61B_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..a813b121e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: er trained on a549_mantis, tested on A549 mantis zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/er_sec61b.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_zikv + model_name: pix2pix2d_unetvit + experiment_id: er__a549_mantis__pix2pix2d_unetvit__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix2d_unetvit/checkpoints/epoch=35-step=8568-loss=0.726.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/a549__zikv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_A549_SEC61B_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..36f865117 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: er trained on a549_mantis, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/er_sec61b.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit + experiment_id: er__a549_mantis__pix2pix2d_unetvit__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix2d_unetvit/checkpoints/epoch=35-step=8568-loss=0.726.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/ipsc/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_A549_SEC61B_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/train.yml new file mode 100644 index 000000000..ee29dc886 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/a549_mantis/train.yml @@ -0,0 +1,102 @@ +# pix2pix2d_unetvit (UNetViT generator + multi-scale PatchGAN, run +# Z-preserving at Z=1) fit on er (Structure channel) — A549 mantis-lightsheet pooled (mock + DENV + ZIKV), +# in-focus 2D track. Mirror of the 3D +# er/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml leaf, +# flattened onto the offline 5-plane in-focus slab store (z_window_size=1 +# emits one in-focus window per plane). +# +# ⚠ Mirrors train_4gpu_modernized.yml, NOT the stale sibling train.yml. The +# published pix2pix3d rows came from the modernized "Run D" recipe — the +# checkpoints carry loss_type='nonsat', lr 2e-4/2e-4, r1_gamma=10, +# ema_kimg=10, lecam_gamma=0.3, lambda_l1=10 and 201 generator_ema.* tensors +# — while train.yml still composes the LSGAN baseline overlay. All of Run D is +# baked into model_overlays/pix2pix2d_unetvit_fit.yml, so unlike the 3D leaves +# this file repeats none of it. +# +# The 3D leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus store. +# The 2D track reads the `_focus.zarr` slab instead, so the resolver is +# disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field co-declared +# with a full dataset_ref. +# +# The train_set fragment supplies data.class_path (HCSDataModule) plus +# split_ratio / mmap_preload / scratch_dir. targets/er_sec61b.yml supplies the +# NormalizeSampled(fov_statistics) normalization the pix2pix leaves use +# (mean/std on Phase3D, median/iqr on the target); only its RandWeightedCropd +# is list-replaced below, flattened [13,624,624] -> [1,624,624]. + +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + gene: SEC61B + target: er + target_id: er + train_set: a549_mantis + model_name: pix2pix2d_unetvit + experiment_id: er__a549_mantis__pix2pix2d_unetvit + # Disable the manifest resolver: the 2D track reads the offline focus store, + # not the manifest-registered non-focus store. + dataset_ref: null + +data: + init_args: + # pooled A549 in-focus slab store (Structure channel) — resolver disabled above. + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all_focus.zarr + # Flatten the target fragment's [13, 624, 624] weighted crop to Z=1. + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 624, 624] + num_samples: 2 + +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_A549_SEC61B + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix2d_unetvit + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + # monitor loss/validate_ema, matching the 3D Run-D leaves: ema_kimg is set, + # so the EMA generator is the one the recipe selects on and the one predict + # reports. Monitoring the raw loss/validate would pin a different epoch. + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix2d_unetvit/checkpoints + +launcher: + job_name: pix2pix2d_unetvit_A549_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix2d_unetvit + sbatch: + # Narrow OFF the hardware_4gpu h100|h200 default, the opposite of the 3D + # leaf. 3D needed h200 because the GAN OOMs 80 GB at Z=8; measured at Z=1 + # on an A40 (44.7 GiB) peak is 13.3 GiB/rank at batch_size 4, so the 48 GB + # cards have 3x headroom and reserving Hopper for this would be queue + # squatting. The profile documents this opt-out explicitly. + constraint: "a40|a6000|l40s|h100|h200" + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D store + # (~1/4 the Z), so the profile's 512G mmap_preload headroom is inherited 3D + # scale. Set in the LEAF BODY because launcher_profiles compose after model + # overlays and would otherwise win. + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/ipsc_confocal/train.yml new file mode 100644 index 000000000..20ff65241 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/ipsc_confocal/train.yml @@ -0,0 +1,102 @@ +# pix2pix2d_unetvit (UNetViT generator + multi-scale PatchGAN, run +# Z-preserving at Z=1) fit on er (Structure channel) — AICS iPSC confocal, +# in-focus 2D track. Mirror of the 3D +# er/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml leaf, +# flattened onto the offline 5-plane in-focus slab store (z_window_size=1 +# emits one in-focus window per plane). +# +# ⚠ Mirrors train_4gpu_modernized.yml, NOT the stale sibling train.yml. The +# published pix2pix3d rows came from the modernized "Run D" recipe — the +# checkpoints carry loss_type='nonsat', lr 2e-4/2e-4, r1_gamma=10, +# ema_kimg=10, lecam_gamma=0.3, lambda_l1=10 and 201 generator_ema.* tensors +# — while train.yml still composes the LSGAN baseline overlay. All of Run D is +# baked into model_overlays/pix2pix2d_unetvit_fit.yml, so unlike the 3D leaves +# this file repeats none of it. +# +# The 3D leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus store. +# The 2D track reads the `_focus.zarr` slab instead, so the resolver is +# disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field co-declared +# with a full dataset_ref. +# +# The train_set fragment supplies data.class_path (HCSDataModule) plus +# split_ratio / mmap_preload / scratch_dir. targets/er_sec61b.yml supplies the +# NormalizeSampled(fov_statistics) normalization the pix2pix leaves use +# (mean/std on Phase3D, median/iqr on the target); only its RandWeightedCropd +# is list-replaced below, flattened [13,624,624] -> [1,624,624]. + +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + gene: SEC61B + target: er + target_id: er + train_set: ipsc_confocal + model_name: pix2pix2d_unetvit + experiment_id: er__ipsc_confocal__pix2pix2d_unetvit + # Disable the manifest resolver: the 2D track reads the offline focus store, + # not the manifest-registered non-focus store. + dataset_ref: null + +data: + init_args: + # aics-hipsc in-focus slab store (Structure channel) — resolver disabled above. + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B_focus.zarr + # Flatten the target fragment's [13, 624, 624] weighted crop to Z=1. + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 624, 624] + num_samples: 2 + +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_iPSC_SEC61B + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/pix2pix2d_unetvit + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + # monitor loss/validate_ema, matching the 3D Run-D leaves: ema_kimg is set, + # so the EMA generator is the one the recipe selects on and the one predict + # reports. Monitoring the raw loss/validate would pin a different epoch. + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/pix2pix2d_unetvit/checkpoints + +launcher: + job_name: pix2pix2d_unetvit_iPSC_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/pix2pix2d_unetvit + sbatch: + # Narrow OFF the hardware_4gpu h100|h200 default, the opposite of the 3D + # leaf. 3D needed h200 because the GAN OOMs 80 GB at Z=8; measured at Z=1 + # on an A40 (44.7 GiB) peak is 13.3 GiB/rank at batch_size 4, so the 48 GB + # cards have 3x headroom and reserving Hopper for this would be queue + # squatting. The profile documents this opt-out explicitly. + constraint: "a40|a6000|l40s|h100|h200" + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D store + # (~1/4 the Z), so the profile's 512G mmap_preload headroom is inherited 3D + # scale. Set in the LEAF BODY because launcher_profiles compose after model + # overlays and would otherwise win. + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..dd04d868f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: er trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/er_sec61b.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_denv + model_name: pix2pix2d_unetvit + experiment_id: er__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix2d_unetvit/checkpoints/epoch=30-step=20336-loss=0.657.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/a549__denv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_JOINT_SEC61B_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..6eef9912d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: er trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/er_sec61b.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_mock + model_name: pix2pix2d_unetvit + experiment_id: er__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix2d_unetvit/checkpoints/epoch=30-step=20336-loss=0.657.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/a549__mock/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_JOINT_SEC61B_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..21868423d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: er trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/er_sec61b.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_zikv + model_name: pix2pix2d_unetvit + experiment_id: er__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix2d_unetvit/checkpoints/epoch=30-step=20336-loss=0.657.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/a549__zikv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_JOINT_SEC61B_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..a255d36ac --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: er trained on joint_ipsc_confocal_a549_mantis, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/er_sec61b.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit + experiment_id: er__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix2d_unetvit/checkpoints/epoch=30-step=20336-loss=0.657.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/ipsc/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_JOINT_SEC61B_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..575fde866 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,170 @@ +# pix2pix2d_unetvit (UNetViT generator + multi-scale PatchGAN, run +# Z-preserving at Z=1) fit on er (Structure channel) — joint ipsc_confocal + a549_mantis pooled, +# in-focus 2D track. Mirror of the 3D +# er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml leaf, +# flattened onto the offline 5-plane in-focus slab store (z_window_size=1 +# emits one in-focus window per plane). +# +# ⚠ Mirrors train_4gpu_modernized.yml, NOT the stale sibling train.yml. The +# published pix2pix3d rows came from the modernized "Run D" recipe — the +# checkpoints carry loss_type='nonsat', lr 2e-4/2e-4, r1_gamma=10, +# ema_kimg=10, lecam_gamma=0.3, lambda_l1=10 and 201 generator_ema.* tensors +# — while train.yml still composes the LSGAN baseline overlay. All of Run D is +# baked into model_overlays/pix2pix2d_unetvit_fit.yml, so unlike the 3D leaves +# this file repeats none of it. +# +# BatchedConcatDataModule + two explicit HCSDataModule children; only +# model_overlays/pix2pix2d_unetvit_fit.yml is composed (the data block is +# authored inline here, not via data_overlays). +# +# Normalization is NormalizeSampled (fov_statistics), matching the single-set +# pix2pix2d leaves — divergent from the celldiff joint, which uses +# MinMaxSampled. Per-organelle prior is to keep joint and single-set +# normalizations identical so ablations are apples-to-apples. +# +# batch_size 2 here, NOT the single-set 4: BatchedConcatDataModule's +# train_dataloader uses batch_size as-is, while HCSDataModule divides by +# RandWeightedCropd num_samples. 2 indices * 2 num_samples = 4 GPU samples per +# rank, x 4 DDP ranks = the same 16 samples/step as the 3D arm. +base: + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + gene: SEC61B + target: er + target_id: er + train_set: joint_ipsc_confocal_a549_mantis + model_name: pix2pix2d_unetvit + experiment_id: er__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit + +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_JOINT_SEC61B + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix2d_unetvit + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + # monitor loss/validate_ema, matching the 3D Run-D leaves: ema_kimg is set, + # so the EMA generator is the one the recipe selects on and the one predict + # reports. Monitoring the raw loss/validate would pin a different epoch. + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix2d_unetvit/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Structure + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: [512, 512] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Structure] + level: fov_statistics + subtrahend: median + divisor: iqr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 624, 624] + num_samples: 2 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [0, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[1, 1], [0.5, 1.5], [0.5, 1.5]] + safe_crop_size: [1, 512, 512] + safe_crop_coverage: 0.9 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0, 0] + val_gpu_augmentations: + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc in-focus slab store (Structure channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B_focus.zarr + # a549_mantis — pooled A549 in-focus slab store (Structure channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all_focus.zarr + +launcher: + job_name: pix2pix2d_unetvit_JOINT_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix2d_unetvit + sbatch: + # Narrow OFF the hardware_4gpu h100|h200 default, the opposite of the 3D + # leaf. 3D needed h200 because the GAN OOMs 80 GB at Z=8; measured at Z=1 + # on an A40 (44.7 GiB) peak is 13.3 GiB/rank at batch_size 4, so the 48 GB + # cards have 3x headroom and reserving Hopper for this would be queue + # squatting. The profile documents this opt-out explicitly. + constraint: "a40|a6000|l40s|h100|h200" + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D store + # (~1/4 the Z), so the profile's 512G mmap_preload headroom is inherited 3D + # scale. Set in the LEAF BODY because launcher_profiles compose after model + # overlays and would otherwise win. + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..6adaade48 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of er/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_denv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: er__a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_sec61b_denv +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix2d_unetvit_wmatch/checkpoints/epoch=39-step=9520-loss=0.732.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/a549/a549__denv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_A549_SEC61B_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..99889d874 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of er/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_mock + model_name: pix2pix2d_unetvit_wmatch + experiment_id: er__a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_sec61b_mock +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix2d_unetvit_wmatch/checkpoints/epoch=39-step=9520-loss=0.732.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/a549/a549__mock/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_A549_SEC61B_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..081c946e1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of er/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_zikv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: er__a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_sec61b_zikv +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix2d_unetvit_wmatch/checkpoints/epoch=39-step=9520-loss=0.732.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/a549/a549__zikv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_A549_SEC61B_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..52211b338 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of er/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch + experiment_id: er__a549_mantis__pix2pix2d_unetvit_wmatch__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix2d_unetvit_wmatch/checkpoints/epoch=39-step=9520-loss=0.732.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/a549/ipsc/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_A549_SEC61B_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/train.yml new file mode 100644 index 000000000..6a270d772 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/a549_mantis/train.yml @@ -0,0 +1,69 @@ +# pix2pix2d `wmatch` arm (fit) of er/pix2pix2d_unetvit/a549_mantis/train.yml. +# Recipe delta: warmup_steps 8500 -> 1183. Run-D's 8500-batch warmup is +# 24.9 % of the matching 3D fit (34200 batches); this 2D fit runs 4760, so +# round(8500 * 4760 / 34200) keeps the same schedule shape. The baseline's absolute 8500 +# left 5 of 12 2D fits still warming up at their last step (wandb lr-AdamW, 2026-10-22). +# Everything else, and the rationale for it, is the baseline leaf's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_fit_leaves.py. +base: +- ../../../_internal/shared/model/train_sets/a549_mantis.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + gene: SEC61B + target: er + target_id: er + train_set: a549_mantis + model_name: pix2pix2d_unetvit_wmatch + experiment_id: er__a549_mantis__pix2pix2d_unetvit_wmatch + dataset_ref: null +data: + init_args: + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Structure + w_key: Structure + spatial_size: + - 1 + - 624 + - 624 + num_samples: 2 +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_wmatch_A549_SEC61B + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix2d_unetvit_wmatch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: epoch={epoch}-step={step}-loss={loss/validate_ema:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix2d_unetvit_wmatch/checkpoints +launcher: + job_name: pix2pix2d_unetvit_wmatch_A549_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix2d_unetvit_wmatch + sbatch: + constraint: a40|a6000|l40s|h100|h200 + mem: 128G +model: + init_args: + warmup_steps: 1183 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..ef9275b08 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of er/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_denv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: er__ipsc_confocal__pix2pix2d_unetvit_wmatch__a549_mantis_sec61b_denv +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/pix2pix2d_unetvit_wmatch/checkpoints/epoch=22-step=9706-loss=0.585.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/ipsc/a549__denv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_SEC61B_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..42c3a2542 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of er/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_mock + model_name: pix2pix2d_unetvit_wmatch + experiment_id: er__ipsc_confocal__pix2pix2d_unetvit_wmatch__a549_mantis_sec61b_mock +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/pix2pix2d_unetvit_wmatch/checkpoints/epoch=22-step=9706-loss=0.585.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/ipsc/a549__mock/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_SEC61B_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..943f058ef --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of er/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_zikv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: er__ipsc_confocal__pix2pix2d_unetvit_wmatch__a549_mantis_sec61b_zikv +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/pix2pix2d_unetvit_wmatch/checkpoints/epoch=22-step=9706-loss=0.585.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_SEC61B_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..f76bd5f19 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of er/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch + experiment_id: er__ipsc_confocal__pix2pix2d_unetvit_wmatch__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/pix2pix2d_unetvit_wmatch/checkpoints/epoch=22-step=9706-loss=0.585.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/ipsc/ipsc/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_SEC61B_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/train.yml new file mode 100644 index 000000000..04c3df147 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/ipsc_confocal/train.yml @@ -0,0 +1,69 @@ +# pix2pix2d `wmatch` arm (fit) of er/pix2pix2d_unetvit/ipsc_confocal/train.yml. +# Recipe delta: warmup_steps 8500 -> 1327. Run-D's 8500-batch warmup is +# 15.7 % of the matching 3D fit (54080 batches); this 2D fit runs 8440, so +# round(8500 * 8440 / 54080) keeps the same schedule shape. The baseline's absolute 8500 +# left 5 of 12 2D fits still warming up at their last step (wandb lr-AdamW, 2026-10-22). +# Everything else, and the rationale for it, is the baseline leaf's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_fit_leaves.py. +base: +- ../../../_internal/shared/model/train_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + gene: SEC61B + target: er + target_id: er + train_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch + experiment_id: er__ipsc_confocal__pix2pix2d_unetvit_wmatch + dataset_ref: null +data: + init_args: + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Structure + w_key: Structure + spatial_size: + - 1 + - 624 + - 624 + num_samples: 2 +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_wmatch_iPSC_SEC61B + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/pix2pix2d_unetvit_wmatch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: epoch={epoch}-step={step}-loss={loss/validate_ema:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/pix2pix2d_unetvit_wmatch/checkpoints +launcher: + job_name: pix2pix2d_unetvit_wmatch_iPSC_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/pix2pix2d_unetvit_wmatch + sbatch: + constraint: a40|a6000|l40s|h100|h200 + mem: 128G +model: + init_args: + warmup_steps: 1327 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..2d2901929 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_denv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: er__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_sec61b_denv +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix2d_unetvit_wmatch/checkpoints/epoch=13-step=9184-loss=0.665.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/joint/a549__denv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_JOINT_SEC61B_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..2826397e0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_mock + model_name: pix2pix2d_unetvit_wmatch + experiment_id: er__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_sec61b_mock +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix2d_unetvit_wmatch/checkpoints/epoch=13-step=9184-loss=0.665.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/joint/a549__mock/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_JOINT_SEC61B_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..a08de72e1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_zikv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: er__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_sec61b_zikv +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix2d_unetvit_wmatch/checkpoints/epoch=13-step=9184-loss=0.665.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/joint/a549__zikv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_JOINT_SEC61B_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..af9a48cad --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch + experiment_id: er__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix2d_unetvit_wmatch/checkpoints/epoch=13-step=9184-loss=0.665.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/er/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/joint/ipsc/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_JOINT_SEC61B_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix2d_unetvit_wmatch/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..c905a9918 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,207 @@ +# pix2pix2d `wmatch` arm (fit) of er/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml. +# Recipe delta: warmup_steps 8500 -> 1271. Run-D's 8500-batch warmup is +# 9.7 % of the matching 3D fit (87720 batches); this 2D fit runs 13120, so +# round(8500 * 13120 / 87720) keeps the same schedule shape. The baseline's absolute 8500 +# left 5 of 12 2D fits still warming up at their last step (wandb lr-AdamW, 2026-10-22). +# Everything else, and the rationale for it, is the baseline leaf's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_fit_leaves.py. +base: +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + gene: SEC61B + target: er + target_id: er + train_set: joint_ipsc_confocal_a549_mantis + model_name: pix2pix2d_unetvit_wmatch + experiment_id: er__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_wmatch_JOINT_SEC61B + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix2d_unetvit_wmatch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: epoch={epoch}-step={step}-loss={loss/validate_ema:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix2d_unetvit_wmatch/checkpoints +_hcs_init_args: + source_channel: Phase3D + target_channel: Structure + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: &id001 + - 512 + - 512 + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: &id002 + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Structure + level: fov_statistics + subtrahend: median + divisor: iqr + augmentations: &id003 + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Structure + w_key: Structure + spatial_size: + - 1 + - 624 + - 624 + num_samples: 2 + gpu_augmentations: &id004 + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: + - source + - target + prob: 0.8 + rotate_range: + - 0 + - 0 + - 0 + shear_range: + - 0.0 + - 0.05 + - 0.05 + scale_range: + - - 1 + - 1 + - - 0.5 + - 1.5 + - - 0.5 + - 1.5 + safe_crop_size: + - 1 + - 512 + - 512 + safe_crop_coverage: 0.9 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: + - source + - target + roi_size: + - 1 + - 512 + - 512 + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: + - source + prob: 0.5 + gamma: + - 0.8 + - 1.2 + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: + - source + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: + - source + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: + - source + prob: 0.5 + sigma_x: + - 0.25 + - 0.75 + sigma_y: + - 0.25 + - 0.75 + sigma_z: + - 0 + - 0 + val_gpu_augmentations: &id005 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: + - source + - target + roi_size: + - 1 + - 512 + - 512 +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + - class_path: viscy_data.hcs.HCSDataModule + init_args: + source_channel: Phase3D + target_channel: Structure + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: *id001 + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: *id002 + augmentations: *id003 + gpu_augmentations: *id004 + val_gpu_augmentations: *id005 + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B_focus.zarr + - class_path: viscy_data.hcs.HCSDataModule + init_args: + source_channel: Phase3D + target_channel: Structure + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: *id001 + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: *id002 + augmentations: *id003 + gpu_augmentations: *id004 + val_gpu_augmentations: *id005 + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all_focus.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_JOINT_SEC61B + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix2d_unetvit_wmatch + sbatch: + constraint: a40|a6000|l40s|h100|h200 + mem: 128G +model: + init_args: + warmup_steps: 1271 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..7a3d64b1b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,48 @@ +# pix2pix3d_unetvit predict: er (SEC61B) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/pix2pix3d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_denv + model_name: pix2pix3d_unetvit + experiment_id: er__a549_mantis__pix2pix3d_unetvit__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix3d_unetvit/checkpoints/epoch=37-step=64980.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__denv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center + +launcher: + job_name: pix2pix3d_unetvit_PRED_SEC61B_A549TR_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..1635a12d8 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,48 @@ +# pix2pix3d_unetvit predict: er (SEC61B) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/pix2pix3d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_mock + model_name: pix2pix3d_unetvit + experiment_id: er__a549_mantis__pix2pix3d_unetvit__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix3d_unetvit/checkpoints/epoch=37-step=64980.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__mock/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center + +launcher: + job_name: pix2pix3d_unetvit_PRED_SEC61B_A549TR_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..c5eca1028 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,48 @@ +# pix2pix3d_unetvit predict: er (SEC61B) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/pix2pix3d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_zikv + model_name: pix2pix3d_unetvit + experiment_id: er__a549_mantis__pix2pix3d_unetvit__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix3d_unetvit/checkpoints/epoch=37-step=64980.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__zikv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center + +launcher: + job_name: pix2pix3d_unetvit_PRED_SEC61B_A549TR_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..f6f7af4da --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,48 @@ +# pix2pix3d_unetvit predict: er (SEC61B) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/pix2pix3d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: pix2pix3d_unetvit + experiment_id: er__a549_mantis__pix2pix3d_unetvit__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix3d_unetvit/checkpoints/epoch=37-step=64980.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/ipsc/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center + +launcher: + job_name: pix2pix3d_unetvit_PRED_SEC61B_A549TR_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/train.yml index c6c16d163..3f13cedfa 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/train.yml @@ -27,6 +27,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml new file mode 100644 index 000000000..0e83fb09f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml @@ -0,0 +1,59 @@ +# pix2pix3d_unetvit MODERNIZED fit on er (Structure channel of SEC61B store) — A549 mantis-lightsheet pooled (mock + DENV + ZIKV), 4-GPU DDP. +# +# Finalized "Run D" recipe: modernized overlay (nonsat + R1 + G-EMA, equal LR) +# + lambda_l1=10 + LeCam gamma=0.3 + 40 epochs. Mirrors the completed nucleus +# modernized runs (same recipe, Structure channel / SEC61B store). Submit with NO overrides. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/data_overlays/unetvit3d_fit.yml + - ../../../_internal/shared/model/model_overlays/pix2pix3d_unetvit_fit_ddp_modernized.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + train_set: a549_mantis + model_name: pix2pix3d_unetvit + experiment_id: er__a549_mantis__pix2pix3d_unetvit_modernized + +model: + init_args: + lambda_l1: 10.0 + lecam_gamma: 0.3 + +trainer: + max_epochs: 40 + logger: + init_args: + name: pix2pix3d_unetvit_A549_SEC61B_4gpu_modernized_lambdaL1_10_lecam_40ep + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix3d_unetvit + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix3d_unetvit/checkpoints + +data: + init_args: + # A549 pooled store + target_channel — no resolver in this train_set. + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all.zarr + +launcher: + job_name: pix2pix3d_unetvit_A549_SEC61B_4gpu_modernized_lambdaL1_10_lecam_40ep + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/pix2pix3d_unetvit + # pix2pix3d GAN (UNetViT3D G + multiscale-patch D, large 3D crops) OOMs on + # 80 GB h100; needs h200 (141 GB). Narrow the hardware_4gpu h100|h200 default. + sbatch: + constraint: h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index 49ea6646d..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by pix2pix3d_unetvit on a549-mantis-sec61b-denv. -defaults: - - override /target: er_sec61b - - override /predict_set: a549_mantis_sec61b_denv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_pix2pix3d_unetvit__sec61b_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_sec61b_pix2pix3d_unetvit__sec61b_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index 669276e73..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by pix2pix3d_unetvit on a549-mantis-sec61b-mock. -defaults: - - override /target: er_sec61b - - override /predict_set: a549_mantis_sec61b_mock - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_pix2pix3d_unetvit__sec61b_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_sec61b_pix2pix3d_unetvit__sec61b_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index 6d06f42ef..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by pix2pix3d_unetvit on a549-mantis-sec61b-zikv. -defaults: - - override /target: er_sec61b - - override /predict_set: a549_mantis_sec61b_zikv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_pix2pix3d_unetvit__sec61b_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_sec61b_pix2pix3d_unetvit__sec61b_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 100644 index eb0dc067c..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by pix2pix3d_unetvit on iPSC confocal. -defaults: - - override /target: er_sec61b - - override /predict_set: ipsc_confocal - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_pix2pix3d_unetvit.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/eval_sec61b_pix2pix3d_unetvit diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml index 8bd75a4b8..d1b18844e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=37-step=102752.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/pix2pix3d_unetvit/checkpoints/epoch=37-step=102752.ckpt data: init_args: @@ -36,8 +36,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_pix2pix3d_unetvit__sec61b_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__denv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_PRED_SEC61B_ON_A549_sec61b_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml index 8ccbbcfb2..e898e5a61 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=37-step=102752.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/pix2pix3d_unetvit/checkpoints/epoch=37-step=102752.ckpt data: init_args: @@ -36,8 +36,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_pix2pix3d_unetvit__sec61b_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__mock/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_PRED_SEC61B_ON_A549_sec61b_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml index bfce661a6..4883a47c4 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=37-step=102752.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/pix2pix3d_unetvit/checkpoints/epoch=37-step=102752.ckpt data: init_args: @@ -36,8 +36,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_pix2pix3d_unetvit__sec61b_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__zikv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_PRED_SEC61B_ON_A549_sec61b_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml index 09346fdb6..6336dc74b 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=37-step=102752.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/pix2pix3d_unetvit/checkpoints/epoch=37-step=102752.ckpt data: init_args: @@ -36,8 +36,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_pix2pix3d_unetvit.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/ipsc/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_PRED_SEC61B - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/train.yml index 9697d2cef..ce7ea122e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/train.yml @@ -27,6 +27,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/train_4gpu.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/train_4gpu.yml index 8cfda5940..0f69a0a9a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/train_4gpu.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/train_4gpu.yml @@ -41,6 +41,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml index 6846d963a..987035b36 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml @@ -41,6 +41,8 @@ trainer: # the inference path (predict_step uses _inference_generator which # prefers EMA when available). monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index 6d684c4c2..1c188956c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/pix2pix3d_unetvit/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix3d_unetvit/checkpoints/epoch=25-step=114036.ckpt data: init_args: @@ -36,8 +36,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/sec61b_pix2pix3d_unetvit__sec61b_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__denv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_JOINT_PRED_SEC61B_ON_A549_sec61b_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index e72661697..5ea45a229 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/pix2pix3d_unetvit/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix3d_unetvit/checkpoints/epoch=25-step=114036.ckpt data: init_args: @@ -36,8 +36,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/sec61b_pix2pix3d_unetvit__sec61b_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__mock/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_JOINT_PRED_SEC61B_ON_A549_sec61b_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index c3b848eaf..dacaf7471 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/pix2pix3d_unetvit/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix3d_unetvit/checkpoints/epoch=25-step=114036.ckpt data: init_args: @@ -36,8 +36,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/sec61b_pix2pix3d_unetvit__sec61b_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__zikv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_JOINT_PRED_SEC61B_ON_A549_sec61b_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index ce065cb3c..16a50272c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/sec61b/pix2pix3d_unetvit/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix3d_unetvit/checkpoints/epoch=25-step=114036.ckpt data: init_args: @@ -36,8 +36,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/sec61b_pix2pix3d_unetvit.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/ipsc/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_JOINT_PRED_SEC61B_ON_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/pix2pix3d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml index 5d25c3343..010a4d9fa 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml @@ -39,6 +39,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml new file mode 100644 index 000000000..6a212fd4a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml @@ -0,0 +1,159 @@ +# pix2pix3d_unetvit MODERNIZED fit on er (Structure marker) — joint ipsc_confocal + a549_mantis pooled, 4-GPU DDP. +# +# Finalized "Run D" recipe: modernized overlay (nonsat + R1 + G-EMA, equal LR) +# + lambda_l1=10 + LeCam gamma=0.3 + 40 epochs. Mirrors the completed nucleus +# modernized runs (same recipe, Structure channel / SEC61B store). Submit with NO overrides. +# +# Joint leaf. Uses BatchedConcatDataModule with two explicit HCSDataModule +# children (no benchmark.dataset_ref — joint leaves bypass the single-dataset +# resolver). Only model_overlays/pix2pix3d_unetvit_fit.yml is composed; the +# data block is authored inline because joint hparams live on the children. +# +# Normalization is NormalizeSampled (fov_statistics) to match the single-set +# pix2pix3d_unetvit leaves — divergent from the celldiff joint which uses +# MinMaxSampled. Per-organelle prior is to keep joint and single-set +# normalizations identical so ablations are apples-to-apples. +# +# Topology: 4-GPU H200 DDP (recipes/topology/ddp_4gpu_gan via the modernized overlay). +base: + - ../../../_internal/shared/model/model_overlays/pix2pix3d_unetvit_fit_ddp_modernized.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + gene: SEC61B + target: er + target_id: er_sec61b + train_set: joint_ipsc_confocal_a549_mantis + model_name: pix2pix3d_unetvit + experiment_id: er__joint_ipsc_confocal_a549_mantis__pix2pix3d_unetvit_modernized + +model: + init_args: + lambda_l1: 10.0 + lecam_gamma: 0.3 + +trainer: + max_epochs: 40 + logger: + init_args: + name: pix2pix3d_unetvit_JOINT_SEC61B_4gpu_modernized_lambdaL1_10_lecam_40ep + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix3d_unetvit + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix3d_unetvit/checkpoints + +# Child HCSDataModule init_args shared across both datasets (only data_path +# differs). `_`-prefixed top-level keys are stripped by load_composed_config +# before reaching LightningCLI; the merge expansion under `data:` survives. +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Structure + z_window_size: 13 + # batch_size=2 + num_samples=2 → 4 GPU samples/step, matching the single-set + # pix2pix3d_unetvit (batch=4, num_samples=2). BatchedConcatDataModule does + # NOT divide by num_samples (see CLAUDE.md), so joint.batch_size = + # single_set.batch_size / num_samples. + batch_size: 2 + num_workers: 4 + yx_patch_size: [512, 512] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Structure] + level: fov_statistics + subtrahend: median + divisor: iqr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [13, 624, 624] + num_samples: 2 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [3.14, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[0.7, 1.3], [0.5, 1.5], [0.5, 1.5]] + safe_crop_size: [8, 512, 512] + safe_crop_coverage: 0.9 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [8, 512, 512] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0.25, 0.75] + val_gpu_augmentations: + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [8, 512, 512] + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B.zarr + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all.zarr + +launcher: + job_name: pix2pix3d_unetvit_JOINT_SEC61B_4gpu_modernized_lambdaL1_10_lecam_40ep + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/pix2pix3d_unetvit + # pix2pix3d GAN (UNetViT3D G + multiscale-patch D, large 3D crops) OOMs on + # 80 GB h100; needs h200 (141 GB). Narrow the hardware_4gpu h100|h200 default. + sbatch: + constraint: h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..2ebbc3b16 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,43 @@ +# unetvit3d predict: er (SEC61B) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_denv + model_name: unetvit3d + experiment_id: er__a549_mantis__unetvit3d__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/unetvit3d/checkpoints/epoch=11-step=40392.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/a549__denv/prediction.zarr + +launcher: + job_name: UNetViT3D_PRED_SEC61B_A549TR_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..66ce65371 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_denv_lite + model_name: unetvit3d + experiment_id: er__a549_mantis__unetvit3d__a549_mantis_sec61b_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/unetvit3d/checkpoints/epoch=11-step=40392.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/a549/a549__denv/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_SEC61B_A549TR_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..cf0993309 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,43 @@ +# unetvit3d predict: er (SEC61B) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_mock + model_name: unetvit3d + experiment_id: er__a549_mantis__unetvit3d__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/unetvit3d/checkpoints/epoch=11-step=40392.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/a549__mock/prediction.zarr + +launcher: + job_name: UNetViT3D_PRED_SEC61B_A549TR_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..c9f989892 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_mock_lite + model_name: unetvit3d + experiment_id: er__a549_mantis__unetvit3d__a549_mantis_sec61b_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/unetvit3d/checkpoints/epoch=11-step=40392.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/a549/a549__mock/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_SEC61B_A549TR_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..cc30eac58 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,43 @@ +# unetvit3d predict: er (SEC61B) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_zikv + model_name: unetvit3d + experiment_id: er__a549_mantis__unetvit3d__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/unetvit3d/checkpoints/epoch=11-step=40392.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/a549__zikv/prediction.zarr + +launcher: + job_name: UNetViT3D_PRED_SEC61B_A549TR_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..6f0ac8d24 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: a549_mantis_sec61b_zikv_lite + model_name: unetvit3d + experiment_id: er__a549_mantis__unetvit3d__a549_mantis_sec61b_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/unetvit3d/checkpoints/epoch=11-step=40392.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/a549/a549__zikv/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_SEC61B_A549TR_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..6de126bdd --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,43 @@ +# unetvit3d predict: er (SEC61B) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: unetvit3d + experiment_id: er__a549_mantis__unetvit3d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/unetvit3d/checkpoints/epoch=11-step=40392.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/ipsc/prediction.zarr + +launcher: + job_name: UNetViT3D_PRED_SEC61B_A549TR_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..55825739a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: a549_mantis + predict_set: ipsc_confocal_lite + model_name: unetvit3d + experiment_id: er__a549_mantis__unetvit3d__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/unetvit3d/checkpoints/epoch=11-step=40392.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/a549/ipsc/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_SEC61B_A549TR_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/train.yml index 8667ebe44..2cd2ff7dd 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/a549_mantis/train.yml @@ -19,7 +19,7 @@ trainer: logger: init_args: name: UNetViT3D_A549_SEC61B - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/sec61b/unetvit3d + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/unetvit3d callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -27,17 +27,19 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/sec61b/unetvit3d/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/unetvit3d/checkpoints data: init_args: # A549 pooled store + target_channel — no resolver in this train_set. target_channel: Structure - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/SEC61B_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all.zarr launcher: job_name: UNetViT3D_A549_SEC61B - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/sec61b/unetvit3d + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/er/unetvit3d diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index 62bd749e1..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by UNetViT3D on a549-mantis-sec61b-denv. -defaults: - - override /target: er_sec61b - - override /predict_set: a549_mantis_sec61b_denv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_unetvit3d__sec61b_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_sec61b_unetvit3d__sec61b_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index fc376dfee..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by UNetViT3D on a549-mantis-sec61b-mock. -defaults: - - override /target: er_sec61b - - override /predict_set: a549_mantis_sec61b_mock - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_unetvit3d__sec61b_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_sec61b_unetvit3d__sec61b_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index beae75161..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by UNetViT3D on a549-mantis-sec61b-zikv. -defaults: - - override /target: er_sec61b - - override /predict_set: a549_mantis_sec61b_zikv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_unetvit3d__sec61b_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_sec61b_unetvit3d__sec61b_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 100644 index 8f4329e08..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: ER (SEC61B) predicted by UNetViT3D on iPSC confocal. -defaults: - - override /target: er_sec61b - - override /predict_set: ipsc_confocal - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_unetvit3d.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/eval_sec61b_unetvit3d diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml index cfccde404..e9c57e7ed 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/unetvit3d/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/unetvit3d/checkpoints/epoch=19-step=108160.ckpt data: init_args: @@ -36,8 +36,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_unetvit3d__sec61b_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/a549__denv/prediction.zarr launcher: job_name: UNetViT3D_PRED_SEC61B_ON_A549_sec61b_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..47657de53 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_denv_lite + model_name: unetvit3d + experiment_id: er__ipsc_confocal__unetvit3d__a549_mantis_sec61b_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/unetvit3d/checkpoints/epoch=19-step=108160.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/ipsc/a549__denv/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_SEC61B_ON_A549_sec61b_denv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml index 7391d1868..cffee158c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/unetvit3d/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/unetvit3d/checkpoints/epoch=19-step=108160.ckpt data: init_args: @@ -36,8 +36,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_unetvit3d__sec61b_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/a549__mock/prediction.zarr launcher: job_name: UNetViT3D_PRED_SEC61B_ON_A549_sec61b_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..0b685123a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_mock_lite + model_name: unetvit3d + experiment_id: er__ipsc_confocal__unetvit3d__a549_mantis_sec61b_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/unetvit3d/checkpoints/epoch=19-step=108160.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/ipsc/a549__mock/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_SEC61B_ON_A549_sec61b_mock_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml index c2cda1647..e5efcef3e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/unetvit3d/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/unetvit3d/checkpoints/epoch=19-step=108160.ckpt data: init_args: @@ -36,8 +36,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/sec61b_unetvit3d__sec61b_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/a549__zikv/prediction.zarr launcher: job_name: UNetViT3D_PRED_SEC61B_ON_A549_sec61b_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..96a85d6a8 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: a549_mantis_sec61b_zikv_lite + model_name: unetvit3d + experiment_id: er__ipsc_confocal__unetvit3d__a549_mantis_sec61b_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/unetvit3d/checkpoints/epoch=19-step=108160.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_SEC61B_ON_A549_sec61b_zikv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml index 1996d089d..3ef1af774 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/unetvit3d/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/unetvit3d/checkpoints/epoch=19-step=108160.ckpt data: init_args: @@ -36,8 +36,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/sec61b_unetvit3d.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/ipsc/prediction.zarr launcher: job_name: UNetViT3D_PRED_SEC61B - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..19ef31223 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/er_sec61b.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: er + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: unetvit3d + experiment_id: er__ipsc_confocal__unetvit3d__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/unetvit3d/checkpoints/epoch=19-step=108160.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/ipsc/ipsc/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_SEC61B_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/er/unetvit3d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/train.yml index d0b03dfd2..973ea9b7f 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/ipsc_confocal/train.yml @@ -19,7 +19,7 @@ trainer: logger: init_args: name: UNetViT3D_iPSC_SEC61B - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/unetvit3d + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/unetvit3d callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -27,11 +27,13 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/unetvit3d/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/unetvit3d/checkpoints launcher: job_name: UNetViT3D_SEC61B - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/sec61b/unetvit3d + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/er/unetvit3d diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..e2837cf5a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,43 @@ +# unetvit3d predict: er (SEC61B) trained on joint_ipsc_confocal_a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_denv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_denv + model_name: unetvit3d + experiment_id: er__joint_ipsc_confocal_a549_mantis__unetvit3d__a549_mantis_sec61b_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/unetvit3d/checkpoints/epoch=19-step=176560.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/a549__denv/prediction.zarr + +launcher: + job_name: UNetViT3D_PRED_SEC61B_JOINTTR_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..1edec3b59 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,43 @@ +# unetvit3d predict: er (SEC61B) trained on joint_ipsc_confocal_a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_mock.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_mock + model_name: unetvit3d + experiment_id: er__joint_ipsc_confocal_a549_mantis__unetvit3d__a549_mantis_sec61b_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/unetvit3d/checkpoints/epoch=19-step=176560.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/a549__mock/prediction.zarr + +launcher: + job_name: UNetViT3D_PRED_SEC61B_JOINTTR_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..086ddca35 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,43 @@ +# unetvit3d predict: er (SEC61B) trained on joint_ipsc_confocal_a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_sec61b_zikv.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_sec61b_zikv + model_name: unetvit3d + experiment_id: er__joint_ipsc_confocal_a549_mantis__unetvit3d__a549_mantis_sec61b_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/unetvit3d/checkpoints/epoch=19-step=176560.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/a549__zikv/prediction.zarr + +launcher: + job_name: UNetViT3D_PRED_SEC61B_JOINTTR_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..291064e2e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,43 @@ +# unetvit3d predict: er (SEC61B) trained on joint_ipsc_confocal_a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/er_sec61b.yml + - ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: er + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: unetvit3d + experiment_id: er__joint_ipsc_confocal_a549_mantis__unetvit3d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/unetvit3d/checkpoints/epoch=19-step=176560.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/ipsc/prediction.zarr + +launcher: + job_name: UNetViT3D_PRED_SEC61B_JOINTTR_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/er/unetvit3d/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/train.yml index 7cc35bed1..bacf2c607 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unetvit3d/joint_ipsc_confocal_a549_mantis/train.yml @@ -29,7 +29,7 @@ trainer: logger: init_args: name: UNetViT3D_JOINT_SEC61B - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/sec61b/unetvit3d + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/unetvit3d callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -37,10 +37,12 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/sec61b/unetvit3d/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/unetvit3d/checkpoints # Child HCSDataModule init_args shared across both datasets (only data_path # differs). Factored as a YAML anchor so the joint leaf stays auditable. @@ -53,7 +55,10 @@ _hcs_init_args: &hcs_init_args source_channel: Phase3D target_channel: Structure z_window_size: 13 - batch_size: 4 + # batch_size=2 + num_samples=2 -> 4 GPU samples/step, matching the single-set + # unetvit3d (batch=4, num_samples=2). BatchedConcatDataModule does NOT divide + # by num_samples (see CLAUDE.md), so joint.batch_size = single/num_samples. + batch_size: 2 num_workers: 4 yx_patch_size: [512, 512] split_ratio: 0.8 @@ -136,11 +141,11 @@ data: - class_path: viscy_data.hcs.HCSDataModule init_args: <<: *hcs_init_args - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/SEC61B_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all.zarr launcher: job_name: UNetViT3D_JOINT_SEC61B - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/sec61b/unetvit3d + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/er/unetvit3d # Joint preloads two stores (iPSC + A549 pool) into /dev/shm; the default # 256G cap is too tight (256G iPSC mem + ~50G A549 + worker peak OOMs). # 512G is the smallest tier that fits joint preload + worker overhead. diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unext2/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unext2/a549_mantis/train.yml index 3b0e02a52..13a8f447a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/unext2/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unext2/a549_mantis/train.yml @@ -37,6 +37,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unext2/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unext2/ipsc_confocal/train.yml index 9121f5692..de7a44498 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/unext2/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unext2/ipsc_confocal/train.yml @@ -37,6 +37,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/er/unext2/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/er/unext2/joint_ipsc_confocal_a549_mantis/train.yml index e1b905ebb..5440d45f7 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/er/unext2/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/er/unext2/joint_ipsc_confocal_a549_mantis/train.yml @@ -45,6 +45,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_denv.yml index 7db172d62..f8f11ba17 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_denv.yml @@ -5,7 +5,7 @@ base: - ../../../_internal/shared/model/targets/membrane.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -20,7 +20,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/memb/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -38,8 +38,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_a549trained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/a549__denv/prediction.zarr launcher: job_name: CELLDiff_A549_PRED_MEMB_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..0fc5a9c53 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,38 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_denv_lite + model_name: celldiff + experiment_id: membrane__a549_mantis__celldiff__a549_mantis_caax_denv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/a549/a549__denv/prediction.zarr +launcher: + job_name: CELLDiff_A549_PRED_MEMB_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_mock.yml index 3442ccfcb..72043b0e2 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_mock.yml @@ -5,7 +5,7 @@ base: - ../../../_internal/shared/model/targets/membrane.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -20,7 +20,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/memb/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -38,8 +38,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_a549trained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/a549__mock/prediction.zarr launcher: job_name: CELLDiff_A549_PRED_MEMB_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..f2d3bc690 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,38 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_mock_lite + model_name: celldiff + experiment_id: membrane__a549_mantis__celldiff__a549_mantis_caax_mock__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/a549/a549__mock/prediction.zarr +launcher: + job_name: CELLDiff_A549_PRED_MEMB_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_movie.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_movie.yml new file mode 100644 index 000000000..74ffcea2e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_movie.yml @@ -0,0 +1,47 @@ +# CellDiff r2 predict: membrane trained on a549_mantis, predicting on the +# cropped A549 TOMM20 DENV movie zarr (125 timepoints). +# No predict_set base — data path set directly to bypass the manifest system. +base: + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_movie + model_name: celldiff + experiment_id: membrane__a549_mantis__celldiff__a549_mantis_movie + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt + predict_method: iterative + predict_overlap: [4, 256, 256] + +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/movie/2024_11_21_A549_TOMM20_DENV_crop.zarr + source_channel: Phase3D + target_channel: Membrane + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + z_window_size: 48 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/a549/movie_predictions/memb_celldiff_r2_a549trained_movie.zarr + +launcher: + job_name: CELLDiff_A549_PRED_MEMB_MOVIE + run_root: /hpc/projects/virtual_staining/training/dynacell/a549/movie_predictions diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_zikv.yml index 14da9590f..f911119bf 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_zikv.yml @@ -5,7 +5,7 @@ base: - ../../../_internal/shared/model/targets/membrane.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -20,7 +20,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/memb/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -38,8 +38,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_a549trained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/a549__zikv/prediction.zarr launcher: job_name: CELLDiff_A549_PRED_MEMB_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..a8a210a8d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,38 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_zikv_lite + model_name: celldiff + experiment_id: membrane__a549_mantis__celldiff__a549_mantis_caax_zikv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/a549/a549__zikv/prediction.zarr +launcher: + job_name: CELLDiff_A549_PRED_MEMB_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__hek_mantis_kras_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__hek_mantis_kras_a549xy.yml new file mode 100644 index 000000000..6b9e14a9f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__hek_mantis_kras_a549xy.yml @@ -0,0 +1,54 @@ +# celldiff predict: membrane trained on a549_mantis, +# predicting against the HEK293T third-cell-type probe (KRAS, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# membrane/celldiff/a549_mantis/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'celldiff_r2' (config dir 'celldiff'). +# z_window_size rescaled 48 -> 64 (the HEK stack depth): this model +# predicts one full-depth window per FOV, not a sliding window. +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_kras_a549xy.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: hek_mantis_kras_a549xy + model_name: celldiff + experiment_id: membrane__a549_mantis__celldiff__hek_mantis_kras_a549xy + dataset_ref: + target: kras +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt + predict_method: iterative + predict_overlap: + - 4 + - 256 + - 256 +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 64 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/hek__a549xy/prediction.zarr +launcher: + job_name: CELLDIFF_PRED_MEMBRANE_A549TR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__ipsc_confocal.yml index 7081f488a..92a8cbf66 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__ipsc_confocal.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/membrane.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/memb/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_celldiff_r2_a549trained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/ipsc/prediction.zarr launcher: job_name: CELLDiff_A549_PRED_MEMB_ON_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..85ede2326 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: ipsc_confocal_lite + model_name: celldiff + experiment_id: membrane__a549_mantis__celldiff__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 40 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/a549/ipsc/prediction.zarr +launcher: + job_name: CELLDiff_A549_PRED_MEMB_ON_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/train.yml index 4971450ef..6081e429a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/a549_mantis/train.yml @@ -19,7 +19,7 @@ trainer: logger: init_args: name: CELLDiff_A549_MEMB - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/memb/celldiff_r2 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_r2 callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -29,7 +29,7 @@ trainer: every_n_epochs: 1 save_top_k: -1 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/memb/celldiff_r2/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_r2/checkpoints data: init_args: @@ -39,4 +39,4 @@ data: launcher: job_name: CELLDiff_A549_MEMB - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/memb/celldiff_r2 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_r2 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index d0186125d..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Membrane (CAAX) predicted by CellDiff on a549-mantis-caax-denv. -# A549 manifest keys membrane by gene (`caax`); override the iPSC-side `membrane` -# target_id from the target group so the resolver finds caax on a549-mantis-caax-denv. -defaults: - - override /target: membrane - - override /predict_set: a549_mantis_caax_denv - -benchmark: - dataset_ref: - target: caax - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_sliding_window_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_memb_celldiff_sliding_window_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index 8c7318119..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Membrane (CAAX) predicted by CellDiff on a549-mantis-caax-mock. -# A549 manifest keys membrane by gene (`caax`); override the iPSC-side `membrane` -# target_id from the target group so the resolver finds caax on a549-mantis-caax-mock. -defaults: - - override /target: membrane - - override /predict_set: a549_mantis_caax_mock - -benchmark: - dataset_ref: - target: caax - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_sliding_window_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_memb_celldiff_sliding_window_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index 79b0b7fc1..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Membrane (CAAX) predicted by CellDiff on a549-mantis-caax-zikv. -# A549 manifest keys membrane by gene (`caax`); override the iPSC-side `membrane` -# target_id from the target group so the resolver finds caax on a549-mantis-caax-zikv. -defaults: - - override /target: membrane - - override /predict_set: a549_mantis_caax_zikv - -benchmark: - dataset_ref: - target: caax - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_sliding_window_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_memb_celldiff_sliding_window_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 100644 index 74852e701..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Membrane predicted by CellDiff on iPSC confocal. -defaults: - - override /target: membrane - - override /predict_set: ipsc_confocal - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_celldiff_sliding_window.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/eval_memb_celldiff_sliding_window diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml index 3641144d8..769697a87 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/membrane.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt predict_method: iterative # denoise, generate, sliding_window, or iterative predict_overlap: [4, 256, 256] @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_iterative_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr launcher: job_name: CELLDiff_PRED_MEMB_ON_A549_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..87518e1de --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,38 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_denv_lite + model_name: celldiff + experiment_id: membrane__ipsc_confocal__celldiff__a549_mantis_caax_denv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr +launcher: + job_name: CELLDiff_PRED_MEMB_ON_A549_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2_iterative/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml index 96b95ebd2..7fb4b0fde 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/membrane.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt predict_method: iterative # denoise, generate, sliding_window, or iterative predict_overlap: [4, 256, 256] @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_iterative_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr launcher: job_name: CELLDiff_PRED_MEMB_ON_A549_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..fb614db3b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,38 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_mock_lite + model_name: celldiff + experiment_id: membrane__ipsc_confocal__celldiff__a549_mantis_caax_mock__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr +launcher: + job_name: CELLDiff_PRED_MEMB_ON_A549_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2_iterative/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml index 075bf03b2..c4e6cdc01 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/membrane.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt predict_method: iterative # denoise, generate, sliding_window, or iterative predict_overlap: [4, 256, 256] @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_celldiff_r2_iterative_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr launcher: job_name: CELLDiff_PRED_MEMB_ON_A549_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..ca2448932 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,38 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_zikv_lite + model_name: celldiff + experiment_id: membrane__ipsc_confocal__celldiff__a549_mantis_caax_zikv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: CELLDiff_PRED_MEMB_ON_A549_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2_iterative/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__hek_mantis_kras_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__hek_mantis_kras_a549xy.yml new file mode 100644 index 000000000..c4e1f0218 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__hek_mantis_kras_a549xy.yml @@ -0,0 +1,54 @@ +# celldiff predict: membrane trained on ipsc_confocal, +# predicting against the HEK293T third-cell-type probe (KRAS, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# membrane/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'celldiff_r2_iterative' (config dir 'celldiff'). +# z_window_size rescaled 48 -> 64 (the HEK stack depth): this model +# predicts one full-depth window per FOV, not a sliding window. +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_kras_a549xy.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: hek_mantis_kras_a549xy + model_name: celldiff + experiment_id: membrane__ipsc_confocal__celldiff__hek_mantis_kras_a549xy + dataset_ref: + target: kras +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt + predict_method: iterative + predict_overlap: + - 4 + - 256 + - 256 +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 64 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/hek__a549xy/prediction.zarr +launcher: + job_name: CELLDIFF_PRED_MEMBRANE_IPSCTR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__ipsc_confocal__denoise.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__ipsc_confocal__denoise.yml index a320f0bf6..1914c9c40 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__ipsc_confocal__denoise.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__ipsc_confocal__denoise.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/membrane.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt predict_method: denoise predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_celldiff_r2_denoise.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_denoise/ipsc/ipsc/prediction.zarr launcher: job_name: CELLDiff_PRED_MEMB_DN - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_denoise/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml index 1281387ea..eee444cb6 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/membrane.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_celldiff_r2_iterative.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr launcher: job_name: CELLDiff_PRED_MEMB_ITER - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_iterative/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative_lite.yml new file mode 100644 index 000000000..860958f78 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: celldiff + experiment_id: membrane__ipsc_confocal__celldiff__ipsc_confocal__iterative__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 40 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr +launcher: + job_name: CELLDiff_PRED_MEMB_ITER_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2_iterative/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__ipsc_confocal__sliding_window.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__ipsc_confocal__sliding_window.yml index 8278e5311..bafa7242d 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__ipsc_confocal__sliding_window.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/predict__ipsc_confocal__sliding_window.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/membrane.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt predict_method: sliding_window predict_overlap: [0, 0, 0] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_celldiff_r2_sliding_window.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_sliding_window/ipsc/ipsc/prediction.zarr launcher: job_name: CELLDiff_PRED_MEMB_SW - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2_sliding_window/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/train.yml index 3f3fb6029..3937b965e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/ipsc_confocal/train.yml @@ -19,7 +19,7 @@ trainer: logger: init_args: name: CELLDiff_iPSC_MEMB - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/celldiff_r2 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_r2 callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -29,8 +29,8 @@ trainer: every_n_epochs: 1 save_top_k: -1 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/celldiff_r2/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_r2/checkpoints launcher: job_name: CELLDiff_MEMB - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/celldiff_r2 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_r2 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index 90dde7675..bde459aff 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/membrane.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/memb/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/celldiff_r2/checkpoints/epoch=19-step=214400.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_celldiff_r2_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/a549__denv/prediction.zarr launcher: job_name: CELLDiff_JOINT_PRED_MEMB_ON_A549_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..a601c2df0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,38 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_denv_lite + model_name: celldiff + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__celldiff__a549_mantis_caax_denv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/celldiff_r2/checkpoints/epoch=19-step=214400.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/joint/a549__denv/prediction.zarr +launcher: + job_name: CELLDiff_JOINT_PRED_MEMB_ON_A549_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index 708acdcf1..c72e873b0 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/membrane.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/memb/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/celldiff_r2/checkpoints/epoch=19-step=214400.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_celldiff_r2_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/a549__mock/prediction.zarr launcher: job_name: CELLDiff_JOINT_PRED_MEMB_ON_A549_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..600e6c598 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,38 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_mock_lite + model_name: celldiff + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__celldiff__a549_mantis_caax_mock__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/celldiff_r2/checkpoints/epoch=19-step=214400.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/joint/a549__mock/prediction.zarr +launcher: + job_name: CELLDiff_JOINT_PRED_MEMB_ON_A549_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_movie.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_movie.yml index ff1c756c5..e503fef42 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_movie.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_movie.yml @@ -5,7 +5,7 @@ base: - ../../../_internal/shared/model/targets/membrane.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -18,7 +18,12 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/memb/celldiff/checkpoints/last.ckpt + # Explicit epoch pin, not `last.ckpt`: `last.ckpt` means "weights at the last + # ModelCheckpoint save", which is a moving target across resumes. This file is + # byte-equivalent to the last.ckpt this leaf previously used (both 1119473017 B, + # same mtime; last.ckpt recorded epoch=19/global_step=214400 and + # best_model_path=epoch=19-step=214400.ckpt), so predictions are unchanged. + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/memb/celldiff/checkpoints/epoch=19-step=214400.ckpt predict_method: iterative predict_overlap: [4, 256, 256] diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index bd5007897..f53ab5094 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/membrane.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/memb/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/celldiff_r2/checkpoints/epoch=19-step=214400.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_celldiff_r2_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/a549__zikv/prediction.zarr launcher: job_name: CELLDiff_JOINT_PRED_MEMB_ON_A549_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..96cfec32f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,38 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_zikv_lite + model_name: celldiff + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__celldiff__a549_mantis_caax_zikv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/celldiff_r2/checkpoints/epoch=19-step=214400.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/joint/a549__zikv/prediction.zarr +launcher: + job_name: CELLDiff_JOINT_PRED_MEMB_ON_A549_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_kras_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_kras_a549xy.yml new file mode 100644 index 000000000..2036cf0df --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_kras_a549xy.yml @@ -0,0 +1,54 @@ +# celldiff predict: membrane trained on joint_ipsc_confocal_a549_mantis, +# predicting against the HEK293T third-cell-type probe (KRAS, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'celldiff_r2' (config dir 'celldiff'). +# z_window_size rescaled 48 -> 64 (the HEK stack depth): this model +# predicts one full-depth window per FOV, not a sliding window. +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_kras_a549xy.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: hek_mantis_kras_a549xy + model_name: celldiff + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__celldiff__hek_mantis_kras_a549xy + dataset_ref: + target: kras +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/celldiff_r2/checkpoints/epoch=19-step=214400.ckpt + predict_method: iterative + predict_overlap: + - 4 + - 256 + - 256 +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 64 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/hek__a549xy/prediction.zarr +launcher: + job_name: CELLDIFF_PRED_MEMBRANE_JOINTTR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index 9f6b68d19..261c12246 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/membrane.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/memb/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/celldiff_r2/checkpoints/epoch=19-step=214400.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/memb_celldiff_r2.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/ipsc/prediction.zarr launcher: job_name: CELLDiff_JOINT_PRED_MEMB_ON_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_r2/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..c69d49286 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal_lite + model_name: celldiff + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__celldiff__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/celldiff_r2/checkpoints/epoch=19-step=214400.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 40 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/joint/ipsc/prediction.zarr +launcher: + job_name: CELLDiff_JOINT_PRED_MEMB_ON_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/celldiff_r2/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/train.yml index 9f0b7aa8f..50916691a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff/joint_ipsc_confocal_a549_mantis/train.yml @@ -33,7 +33,7 @@ trainer: logger: init_args: name: CELLDiff_JOINT_MEMB - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/memb/celldiff_r2 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/celldiff_r2 callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -43,7 +43,7 @@ trainer: every_n_epochs: 1 save_top_k: -1 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/memb/celldiff_r2/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/celldiff_r2/checkpoints _hcs_init_args: &hcs_init_args source_channel: Phase3D @@ -130,7 +130,7 @@ data: launcher: job_name: CELLDiff_JOINT_MEMB - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/memb/celldiff_r2 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/celldiff_r2 # Joint preloads two stores (iPSC + A549 pool) into /dev/shm; the default # 256G cap is too tight (256G iPSC mem + ~50G A549 + worker peak OOMs). # 512G is the smallest tier that fits joint preload + worker overhead. diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..b4222bd9f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# CellDiff-2D predict: membrane trained on a549_mantis, tested on a549-mantis-caax-denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_denv + model_name: celldiff_2d + experiment_id: membrane__a549_mantis__celldiff_2d__a549_mantis_caax_denv + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_denv. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_2d/checkpoints/epoch=19-step=12000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/a549__denv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_A549_MEMB_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..ecccd71c9 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# CellDiff-2D predict: membrane trained on a549_mantis, tested on a549-mantis-caax-mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_mock + model_name: celldiff_2d + experiment_id: membrane__a549_mantis__celldiff_2d__a549_mantis_caax_mock + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_mock. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_2d/checkpoints/epoch=19-step=12000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/a549__mock/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_A549_MEMB_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..974b290c2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# CellDiff-2D predict: membrane trained on a549_mantis, tested on a549-mantis-caax-zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_zikv + model_name: celldiff_2d + experiment_id: membrane__a549_mantis__celldiff_2d__a549_mantis_caax_zikv + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_zikv. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_2d/checkpoints/epoch=19-step=12000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/a549__zikv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_A549_MEMB_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..f1e50ddbd --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: membrane trained on a549_mantis, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: celldiff_2d + experiment_id: membrane__a549_mantis__celldiff_2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_2d/checkpoints/epoch=19-step=12000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/ipsc/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_A549_MEMB_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/train.yml new file mode 100644 index 000000000..e2fdb1ceb --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/a549_mantis/train.yml @@ -0,0 +1,82 @@ +# CellDiff-2D (CELLDiffNet run Z-preserving at Z=1) fit on membrane (Membrane +# channel) — a549_mantis, in-focus 2D track. Mirror of the 3D +# membrane/celldiff/a549_mantis fit leaf, flattened onto the offline +# 5-plane in-focus slab store (z_window_size=1 emits one in-focus window +# per plane). +# +# The 3D leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus store. +# The 2D track reads the `_focus.zarr` slab instead, so the resolver is +# disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field +# co-declared with a full dataset_ref. +# +# The train_set fragment supplies data.class_path (HCSDataModule) plus +# split_ratio / mmap_preload / scratch_dir — without it the resolved +# config has an init_args-only data block and `dynacell fit` fails to +# build the datamodule. targets/membrane_celldiff.yml supplies the +# MinMaxSampled(timepoint_statistics) normalization CellDiff needs +# (p1/p99 -> [-1,1], not mean/std); only its RandWeightedCropd is +# list-replaced below, flattened [13,624,624] -> [1,624,624]. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/membrane_celldiff.yml + - ../../../_internal/shared/model/data_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + gene: Membrane + target: membrane + target_id: membrane + train_set: a549_mantis + model_name: celldiff_2d + experiment_id: membrane__a549_mantis__celldiff_2d + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered non-focus store. + dataset_ref: null + +data: + init_args: + # pooled dual nucl+memb in-focus slab store (Membrane channel) — resolver disabled above. + source_channel: Phase3D + target_channel: Membrane + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + # Flatten the target fragment's [13, 624, 624] weighted crop to Z=1. + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Membrane] + w_key: Membrane + spatial_size: [1, 624, 624] + num_samples: 2 + + +trainer: + logger: + init_args: + name: CELLDiff2D_A549_MEMB + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + every_n_epochs: 1 + save_top_k: -1 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_2d/checkpoints + +launcher: + job_name: CELLDiff2D_A549_MEMB + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/celldiff_2d + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D + # store (~1/4 the Z), so the 512G headroom the 3D leaf needed for + # mmap_preload is wasteful and delays scheduling. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..998d09b42 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# CellDiff-2D predict: membrane trained on ipsc_confocal, tested on a549-mantis-caax-denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_denv + model_name: celldiff_2d + experiment_id: membrane__ipsc_confocal__celldiff_2d__a549_mantis_caax_denv + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_denv. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_2d/checkpoints/epoch=19-step=20000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_MEMB_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..fe60e62f7 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# CellDiff-2D predict: membrane trained on ipsc_confocal, tested on a549-mantis-caax-mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_mock + model_name: celldiff_2d + experiment_id: membrane__ipsc_confocal__celldiff_2d__a549_mantis_caax_mock + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_mock. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_2d/checkpoints/epoch=19-step=20000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_MEMB_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..7d4cad3d2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# CellDiff-2D predict: membrane trained on ipsc_confocal, tested on a549-mantis-caax-zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_zikv + model_name: celldiff_2d + experiment_id: membrane__ipsc_confocal__celldiff_2d__a549_mantis_caax_zikv + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_zikv. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_2d/checkpoints/epoch=19-step=20000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_MEMB_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..ecec72470 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: membrane trained on ipsc_confocal, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: celldiff_2d + experiment_id: membrane__ipsc_confocal__celldiff_2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_2d/checkpoints/epoch=19-step=20000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/ipsc/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_MEMB_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/train.yml new file mode 100644 index 000000000..814428320 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/ipsc_confocal/train.yml @@ -0,0 +1,82 @@ +# CellDiff-2D (CELLDiffNet run Z-preserving at Z=1) fit on membrane (Membrane +# channel) — ipsc_confocal, in-focus 2D track. Mirror of the 3D +# membrane/celldiff/ipsc_confocal fit leaf, flattened onto the offline +# 5-plane in-focus slab store (z_window_size=1 emits one in-focus window +# per plane). +# +# The 3D leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus store. +# The 2D track reads the `_focus.zarr` slab instead, so the resolver is +# disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field +# co-declared with a full dataset_ref. +# +# The train_set fragment supplies data.class_path (HCSDataModule) plus +# split_ratio / mmap_preload / scratch_dir — without it the resolved +# config has an init_args-only data block and `dynacell fit` fails to +# build the datamodule. targets/membrane_celldiff.yml supplies the +# MinMaxSampled(timepoint_statistics) normalization CellDiff needs +# (p1/p99 -> [-1,1], not mean/std); only its RandWeightedCropd is +# list-replaced below, flattened [13,624,624] -> [1,624,624]. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane_celldiff.yml + - ../../../_internal/shared/model/data_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + gene: Membrane + target: membrane + target_id: membrane + train_set: ipsc_confocal + model_name: celldiff_2d + experiment_id: membrane__ipsc_confocal__celldiff_2d + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered non-focus store. + dataset_ref: null + +data: + init_args: + # aics-hipsc multi-marker in-focus slab store (Membrane channel) — resolver disabled above. + source_channel: Phase3D + target_channel: Membrane + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + # Flatten the target fragment's [13, 624, 624] weighted crop to Z=1. + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Membrane] + w_key: Membrane + spatial_size: [1, 624, 624] + num_samples: 2 + + +trainer: + logger: + init_args: + name: CELLDiff2D_iPSC_MEMB + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + every_n_epochs: 1 + save_top_k: -1 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_2d/checkpoints + +launcher: + job_name: CELLDiff2D_MEMB + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_2d + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D + # store (~1/4 the Z), so the 512G headroom the 3D leaf needed for + # mmap_preload is wasteful and delays scheduling. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..db36a86a1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# CellDiff-2D predict: membrane trained on joint_ipsc_confocal_a549_mantis, tested on a549-mantis-caax-denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_denv + model_name: celldiff_2d + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__celldiff_2d__a549_mantis_caax_denv + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_denv. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/celldiff_2d/checkpoints/epoch=19-step=32000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/a549__denv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_JOINT_MEMB_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..a1107b138 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# CellDiff-2D predict: membrane trained on joint_ipsc_confocal_a549_mantis, tested on a549-mantis-caax-mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_mock + model_name: celldiff_2d + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__celldiff_2d__a549_mantis_caax_mock + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_mock. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/celldiff_2d/checkpoints/epoch=19-step=32000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/a549__mock/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_JOINT_MEMB_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..f32d57cf2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# CellDiff-2D predict: membrane trained on joint_ipsc_confocal_a549_mantis, tested on a549-mantis-caax-zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_zikv + model_name: celldiff_2d + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__celldiff_2d__a549_mantis_caax_zikv + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_zikv. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/celldiff_2d/checkpoints/epoch=19-step=32000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/a549__zikv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_JOINT_MEMB_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..84af9c279 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: membrane trained on joint_ipsc_confocal_a549_mantis, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: celldiff_2d + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__celldiff_2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/celldiff_2d/checkpoints/epoch=19-step=32000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/ipsc/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_JOINT_MEMB_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..a72e7dff0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,138 @@ +# CellDiff-2D (CELLDiffNet run Z-preserving at Z=1) fit on membrane (Membrane) +# — joint ipsc_confocal + a549_mantis pooled, in-focus 2D track. Mirror of +# the 3D membrane/celldiff/joint_* fit leaf, flattened onto the offline +# 5-plane in-focus slab stores. +# +# BatchedConcatDataModule + two explicit HCSDataModule children; only +# model_overlays/celldiff_2d_fit.yml is composed (the data block is +# authored inline here, not via data_overlays). +# +# batch_size 2 here, NOT the single-set 4: BatchedConcatDataModule's +# train_dataloader uses batch_size as-is, while HCSDataModule divides by +# RandWeightedCropd num_samples. 2 indices * 2 num_samples = 4 GPU +# samples, matching the single-set leaves. +base: + - ../../../_internal/shared/model/model_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + gene: Membrane + target: membrane + target_id: membrane + train_set: joint_ipsc_confocal_a549_mantis + model_name: celldiff_2d + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__celldiff_2d + +trainer: + logger: + init_args: + name: CELLDiff2D_JOINT_MEMB + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/celldiff_2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + every_n_epochs: 1 + save_top_k: -1 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/celldiff_2d/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Membrane + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: [512, 512] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Membrane] + level: timepoint_statistics + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Membrane] + w_key: Membrane + spatial_size: [1, 624, 624] + num_samples: 2 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [0, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[1, 1], [0.5, 1.5], [0.5, 1.5]] + safe_crop_size: [1, 512, 512] + safe_crop_coverage: 0.9 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0, 0] + val_gpu_augmentations: + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] + + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc multi-marker in-focus slab store (Membrane channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + # a549_mantis — pooled dual nucl+memb in-focus slab store (Membrane channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + +launcher: + job_name: CELLDiff2D_JOINT_MEMB + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/celldiff_2d + # 128G: both children preload 5-plane in-focus slabs (~1/4 the Z of the + # 3D stores), so the 512G the 3D joint leaf needed is wasteful here. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..36186351d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,43 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf membrane/celldiff_2d/ipsc_confocal/predict__a549_mantis_denv.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_denv + model_name: celldiff_2d_seed1 + experiment_id: membrane__ipsc_confocal__celldiff_2d_seed1__a549_mantis_caax_denv + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_2d_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d_seed1/ipsc/a549__denv/prediction.zarr +launcher: + job_name: CELLDiff2D_PRED_MEMB_ON_A549_DENV_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d_seed1/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..9cb6edac6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,43 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf membrane/celldiff_2d/ipsc_confocal/predict__a549_mantis_mock.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_mock + model_name: celldiff_2d_seed1 + experiment_id: membrane__ipsc_confocal__celldiff_2d_seed1__a549_mantis_caax_mock + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_2d_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d_seed1/ipsc/a549__mock/prediction.zarr +launcher: + job_name: CELLDiff2D_PRED_MEMB_ON_A549_MOCK_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d_seed1/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..cd92a4c2c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,43 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf membrane/celldiff_2d/ipsc_confocal/predict__a549_mantis_zikv.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_zikv + model_name: celldiff_2d_seed1 + experiment_id: membrane__ipsc_confocal__celldiff_2d_seed1__a549_mantis_caax_zikv + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_2d_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d_seed1/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: CELLDiff2D_PRED_MEMB_ON_A549_ZIKV_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d_seed1/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..8b94a6afa --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,41 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf membrane/celldiff_2d/ipsc_confocal/predict__ipsc_confocal.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: celldiff_2d_seed1 + experiment_id: membrane__ipsc_confocal__celldiff_2d_seed1__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_2d_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d_seed1/ipsc/ipsc/prediction.zarr +launcher: + job_name: CELLDiff2D_PRED_MEMB_ON_IPSC_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/celldiff_2d_seed1/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/train.yml new file mode 100644 index 000000000..269ae3c83 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/celldiff_2d_seed1/ipsc_confocal/train.yml @@ -0,0 +1,61 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (fit) of the baseline leaf membrane/celldiff_2d/ipsc_confocal/train.yml. +# Recipe delta vs that leaf: seed_everything: 1. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/train_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/membrane_celldiff.yml +- ../../../_internal/shared/model/data_overlays/celldiff_2d_fit.yml +- ../../../_internal/shared/model/model_overlays/celldiff_2d_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + gene: Membrane + target: membrane + target_id: membrane + train_set: ipsc_confocal + model_name: celldiff_2d_seed1 + experiment_id: membrane__ipsc_confocal__celldiff_2d_seed1 + dataset_ref: null +data: + init_args: + source_channel: Phase3D + target_channel: Membrane + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Membrane + w_key: Membrane + spatial_size: + - 1 + - 624 + - 624 + num_samples: 2 +trainer: + logger: + init_args: + name: CELLDiff2D_iPSC_MEMB_seed1 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_2d_seed1 + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + every_n_epochs: 1 + save_top_k: -1 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_2d_seed1/checkpoints +launcher: + job_name: CELLDiff2D_MEMB_seed1 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/celldiff_2d_seed1 + sbatch: + mem: 128G +seed_everything: 1 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..8577a7545 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: membrane trained on a549_mantis, +# tested on a549-mantis-caax-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_denv + model_name: fcmae_vscyto2d_pretrained + experiment_id: membrane__a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_caax_denv + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_denv. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto2d_pretrained/checkpoints/epoch=74-step=22500-loss=0.401.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_A549TR_MEMB_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..27ddab873 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: membrane trained on a549_mantis, +# tested on a549-mantis-caax-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_mock + model_name: fcmae_vscyto2d_pretrained + experiment_id: membrane__a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_caax_mock + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_mock. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto2d_pretrained/checkpoints/epoch=74-step=22500-loss=0.401.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_A549TR_MEMB_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..56a992c08 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: membrane trained on a549_mantis, +# tested on a549-mantis-caax-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_zikv + model_name: fcmae_vscyto2d_pretrained + experiment_id: membrane__a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_caax_zikv + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_zikv. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto2d_pretrained/checkpoints/epoch=74-step=22500-loss=0.401.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_A549TR_MEMB_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..86606ecdc --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: membrane trained on a549_mantis, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_pretrained + experiment_id: membrane__a549_mantis__fcmae_vscyto2d_pretrained__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto2d_pretrained/checkpoints/epoch=74-step=22500-loss=0.401.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_A549TR_MEMB_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/train.yml new file mode 100644 index 000000000..3fa33ca6b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/a549_mantis/train.yml @@ -0,0 +1,84 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) with FCMAE-2D +# pretrained encoder init on membrane (Membrane marker), in-focus 2D +# benchmark track, A549 mantis pooled (mock + DENV + ZIKV). Paper key: +# VSCyto2D. Companion to fcmae_vscyto2d_scratch — the two leaves are +# identical except this one loads the 2D FCMAE encoder weights and drops +# lr to 0.0002 (mirroring cytoland VSCyto2D finetuning). +# +# Reads the offline 5-plane in-focus slab store dual_nucl_memb_all_focus.zarr +# (extracted from the 3D dual_nucl_memb_all.zarr; z_window_size=1 emits one +# in-focus window per plane). Mirror of the 3D +# membrane/fcmae_vscyto3d_pretrained/a549_mantis fit leaf. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + train_set: a549_mantis + model_name: fcmae_vscyto2d_pretrained + experiment_id: membrane__a549_mantis__fcmae_vscyto2d_pretrained + +# Override the FCMAE-2D data overlay's hardcoded `Structure` augmentation +# keys (the overlay was authored for ER/Mito where target_channel == +# "Structure"). RandWeightedCropd needs the actual membrane channel name in +# keys/w_key. spatial_size + num_samples kept identical to the FCMAE-2D +# overlay so the augmentation policy matches ER/Mito. +data: + init_args: + # A549 pooled in-focus slab store + target_channel — no resolver in + # this train_set. Nucleus + membrane share dual_nucl_memb_all_focus.zarr. + target_channel: Membrane + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Membrane] + w_key: Membrane + spatial_size: [1, 600, 600] + num_samples: 4 + +model: + init_args: + # Load only the encoder from the 2D FCMAE ckpt (400 ep on HEK + A549 + + # BJ5a + LIVECell + CTMC phase data); decoder/head stay at fresh init. + # lr 0.0002 overrides the overlay's 0.0004 for pretrained finetuning. + encoder_only: true + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/fcmae-2d/pretrain-logs/hek-a549-bj5a-livecell-ctmc-400ep/checkpoints/last.ckpt + lr: 0.0002 + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Pretrained_A549_Membrane + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto2d_pretrained + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto2d_pretrained/checkpoints + +launcher: + job_name: FCMAE_VSCyto2D_Pretrained_A549_Membrane + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto2d_pretrained + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..9fa37f6e3 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: membrane trained on ipsc_confocal, +# tested on a549-mantis-caax-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_denv + model_name: fcmae_vscyto2d_pretrained + experiment_id: membrane__ipsc_confocal__fcmae_vscyto2d_pretrained__a549_mantis_caax_denv + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_denv. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_pretrained/checkpoints/epoch=178-step=89500-loss=0.485.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_MEMB_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..735438585 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: membrane trained on ipsc_confocal, +# tested on a549-mantis-caax-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_mock + model_name: fcmae_vscyto2d_pretrained + experiment_id: membrane__ipsc_confocal__fcmae_vscyto2d_pretrained__a549_mantis_caax_mock + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_mock. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_pretrained/checkpoints/epoch=178-step=89500-loss=0.485.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_MEMB_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..cee02992c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: membrane trained on ipsc_confocal, +# tested on a549-mantis-caax-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_zikv + model_name: fcmae_vscyto2d_pretrained + experiment_id: membrane__ipsc_confocal__fcmae_vscyto2d_pretrained__a549_mantis_caax_zikv + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_zikv. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_pretrained/checkpoints/epoch=178-step=89500-loss=0.485.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_MEMB_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..81f296116 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: membrane trained on ipsc_confocal, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_pretrained + experiment_id: membrane__ipsc_confocal__fcmae_vscyto2d_pretrained__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_pretrained/checkpoints/epoch=178-step=89500-loss=0.485.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_MEMB_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/train.yml new file mode 100644 index 000000000..356e46e8a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/ipsc_confocal/train.yml @@ -0,0 +1,93 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) with FCMAE-2D +# pretrained encoder init on membrane (Membrane marker), in-focus 2D +# benchmark track, iPSC confocal (aics-hipsc). Paper key: VSCyto2D. +# Companion to fcmae_vscyto2d_scratch — the two leaves are identical +# except this one loads the 2D FCMAE encoder weights and drops lr to +# 0.0002 (mirroring cytoland VSCyto2D finetuning). +# +# The 3D ipsc leaf resolves data_path/source_channel/target_channel from +# the manifest via benchmark.dataset_ref, which points at the NON-focus +# cell.zarr. The 2D track reads the offline 5-plane in-focus slab store +# cell_focus.zarr instead, so the resolver is disabled here +# (dataset_ref: null) and the three data fields are declared inline — the +# resolver hook raises on any data.init_args field co-declared with a full +# dataset_ref. source_channel/target_channel reproduce the resolver's +# manifest output (Phase3D / Membrane). Mirror of the 3D +# membrane/fcmae_vscyto3d_pretrained/ipsc_confocal fit leaf. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + train_set: ipsc_confocal + model_name: fcmae_vscyto2d_pretrained + experiment_id: membrane__ipsc_confocal__fcmae_vscyto2d_pretrained + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered cell.zarr. dataset_ref: null makes + # the compose hook a no-op so data fields can be declared inline. + dataset_ref: null + +# Override the FCMAE-2D data overlay's hardcoded `Structure` augmentation +# keys (the overlay was authored for ER/Mito where target_channel == +# "Structure"). RandWeightedCropd needs the actual membrane channel name in +# keys/w_key. spatial_size + num_samples kept identical to the FCMAE-2D +# overlay so the augmentation policy matches ER/Mito. +data: + init_args: + # iPSC in-focus slab store + channels — resolver disabled above. + source_channel: Phase3D + target_channel: Membrane + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Membrane] + w_key: Membrane + spatial_size: [1, 600, 600] + num_samples: 4 + +model: + init_args: + # Load only the encoder from the 2D FCMAE ckpt (400 ep on HEK + A549 + + # BJ5a + LIVECell + CTMC phase data); decoder/head stay at fresh init. + # lr 0.0002 overrides the overlay's 0.0004 for pretrained finetuning. + encoder_only: true + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/fcmae-2d/pretrain-logs/hek-a549-bj5a-livecell-ctmc-400ep/checkpoints/last.ckpt + lr: 0.0002 + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Pretrained_iPSC_Membrane + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_pretrained + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_pretrained/checkpoints + +launcher: + job_name: FCMAE_VSCyto2D_Pretrained_Membrane + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_pretrained + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..ade278b43 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: membrane trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-caax-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_denv + model_name: fcmae_vscyto2d_pretrained + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_caax_denv + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_denv. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto2d_pretrained/checkpoints/epoch=93-step=75200-loss=0.481.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_JOINT_MEMB_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..22c55789a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: membrane trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-caax-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_mock + model_name: fcmae_vscyto2d_pretrained + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_caax_mock + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_mock. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto2d_pretrained/checkpoints/epoch=93-step=75200-loss=0.481.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_JOINT_MEMB_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..d5ad84432 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: membrane trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-caax-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_zikv + model_name: fcmae_vscyto2d_pretrained + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_caax_zikv + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_zikv. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto2d_pretrained/checkpoints/epoch=93-step=75200-loss=0.481.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_JOINT_MEMB_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..319177cd8 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: membrane trained on joint_ipsc_confocal_a549_mantis, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_pretrained + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto2d_pretrained/checkpoints/epoch=93-step=75200-loss=0.481.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_JOINT_MEMB_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_pretrained/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..647d8c90f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,165 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) with FCMAE-2D +# pretrained encoder init on membrane (MEMB) — joint +# ipsc_confocal + a549_mantis pooled, in-focus 2D benchmark track. +# Paper key: VSCyto2D. Companion to the fcmae_vscyto2d_scratch joint +# leaf — the two are identical except this one loads the 2D FCMAE +# encoder weights and drops lr to 0.0002 (mirroring cytoland VSCyto2D +# finetuning). Mirrors membrane/fcmae_vscyto2d_pretrained/ipsc_confocal +# on the joint train_set, flattened to the 2D focus-slab geometry. +# +# Joint leaf: BatchedConcatDataModule with two explicit HCSDataModule +# children (no benchmark.dataset_ref — joint leaves bypass the single- +# dataset resolver, so both child data_paths are the offline +# `_focus.zarr` slab stores directly). Only +# model_overlays/fcmae_vscyto2d_fit.yml is composed; the data block is +# authored inline because joint hparams live on the children. +# +# Topology: single-GPU (inherited from model_overlays/fcmae_vscyto2d_fit.yml +# single_gpu base). z_window_size=1 reads one in-focus plane per window; +# BatchedConcatDataModule does NOT divide batch_size by num_samples, so +# batch_size=4 * num_samples=4 = 16 GPU samples/step, matching the +# single-set 2D data overlay's effective 16. +base: + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + gene: Membrane + target: membrane + target_id: membrane + train_set: joint_ipsc_confocal_a549_mantis + model_name: fcmae_vscyto2d_pretrained + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained + +model: + init_args: + # Load only the encoder from the 2D FCMAE ckpt (400 ep on HEK + A549 + + # BJ5a + LIVECell + CTMC phase data); decoder/head stay at fresh init. + # lr 0.0002 overrides the overlay's 0.0004 for pretrained finetuning. + encoder_only: true + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/fcmae-2d/pretrain-logs/hek-a549-bj5a-livecell-ctmc-400ep/checkpoints/last.ckpt + lr: 0.0002 + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Pretrained_JOINT_MEMB + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto2d_pretrained + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto2d_pretrained/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Membrane + z_window_size: 1 + # batch_size is NOT divided by num_samples in joint mode: 4 indices * + # num_samples=4 = 16 GPU samples per rank, matching the single-set 2D + # data overlay's effective 16. + batch_size: 4 + num_workers: 4 + yx_patch_size: [384, 384] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Membrane] + level: fov_statistics + subtrahend: median + divisor: iqr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Membrane] + w_key: Membrane + spatial_size: [1, 600, 600] + num_samples: 4 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [0, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[1, 1], [0.5, 1.5], [0.5, 1.5]] + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 384, 384] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0, 0] + val_gpu_augmentations: + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 384, 384] + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc multi-marker in-focus slab (Membrane channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + # a549_mantis — pooled dual nucl+memb in-focus slab (Membrane channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + +launcher: + job_name: FCMAE_VSCyto2D_Pretrained_JOINT_MEMB + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto2d_pretrained + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..5636f0bd2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: membrane trained on a549_mantis, +# tested on a549-mantis-caax-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_denv + model_name: fcmae_vscyto2d_scratch + experiment_id: membrane__a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_caax_denv + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_denv. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto2d_scratch/checkpoints/epoch=132-step=39900-loss=0.435.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_A549TR_MEMB_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..c453cb4e0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: membrane trained on a549_mantis, +# tested on a549-mantis-caax-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_mock + model_name: fcmae_vscyto2d_scratch + experiment_id: membrane__a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_caax_mock + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_mock. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto2d_scratch/checkpoints/epoch=132-step=39900-loss=0.435.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_A549TR_MEMB_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..03c7bcb43 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: membrane trained on a549_mantis, +# tested on a549-mantis-caax-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_zikv + model_name: fcmae_vscyto2d_scratch + experiment_id: membrane__a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_caax_zikv + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_zikv. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto2d_scratch/checkpoints/epoch=132-step=39900-loss=0.435.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_A549TR_MEMB_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..05641c1cc --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: membrane trained on a549_mantis, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch + experiment_id: membrane__a549_mantis__fcmae_vscyto2d_scratch__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto2d_scratch/checkpoints/epoch=132-step=39900-loss=0.435.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_A549TR_MEMB_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/train.yml new file mode 100644 index 000000000..9be0dac69 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/a549_mantis/train.yml @@ -0,0 +1,75 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) random-init baseline +# on membrane (Membrane marker), in-focus 2D benchmark track, A549 mantis +# pooled (mock + DENV + ZIKV). Paper key: UNeXt2-2D. Scratch control for +# the fcmae_vscyto2d_pretrained (VSCyto2D) counterpart — the two leaves +# are identical except this one does NOT load pretrained encoder weights. +# +# Reads the offline 5-plane in-focus slab store dual_nucl_memb_all_focus.zarr +# (extracted from the 3D dual_nucl_memb_all.zarr; z_window_size=1 emits one +# in-focus window per plane). Mirror of the 3D +# membrane/fcmae_vscyto3d_scratch/a549_mantis fit leaf. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + train_set: a549_mantis + model_name: fcmae_vscyto2d_scratch + experiment_id: membrane__a549_mantis__fcmae_vscyto2d_scratch + +# Override the FCMAE-2D data overlay's hardcoded `Structure` augmentation +# keys (the overlay was authored for ER/Mito where target_channel == +# "Structure"). RandWeightedCropd needs the actual membrane channel name +# in keys/w_key. spatial_size + num_samples kept identical to the FCMAE-2D +# overlay so the augmentation policy matches ER/Mito. +data: + init_args: + # A549 pooled in-focus slab store + target_channel — no resolver in + # this train_set. Nucleus + membrane share dual_nucl_memb_all_focus.zarr + # (the nucleus 2D leaf re-keys to Nuclei). + target_channel: Membrane + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Membrane] + w_key: Membrane + spatial_size: [1, 600, 600] + num_samples: 4 + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Scratch_A549_Membrane + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto2d_scratch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto2d_scratch/checkpoints + +launcher: + job_name: FCMAE_VSCyto2D_Scratch_A549_Membrane + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto2d_scratch + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..ceb37d263 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: membrane trained on ipsc_confocal, +# tested on a549-mantis-caax-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_denv + model_name: fcmae_vscyto2d_scratch + experiment_id: membrane__ipsc_confocal__fcmae_vscyto2d_scratch__a549_mantis_caax_denv + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_denv. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_scratch/checkpoints/epoch=190-step=95500-loss=0.498.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_MEMB_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..0940434f0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: membrane trained on ipsc_confocal, +# tested on a549-mantis-caax-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_mock + model_name: fcmae_vscyto2d_scratch + experiment_id: membrane__ipsc_confocal__fcmae_vscyto2d_scratch__a549_mantis_caax_mock + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_mock. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_scratch/checkpoints/epoch=190-step=95500-loss=0.498.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_MEMB_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..22a0524a5 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: membrane trained on ipsc_confocal, +# tested on a549-mantis-caax-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_zikv + model_name: fcmae_vscyto2d_scratch + experiment_id: membrane__ipsc_confocal__fcmae_vscyto2d_scratch__a549_mantis_caax_zikv + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_zikv. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_scratch/checkpoints/epoch=190-step=95500-loss=0.498.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_MEMB_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..fa03c120d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: membrane trained on ipsc_confocal, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch + experiment_id: membrane__ipsc_confocal__fcmae_vscyto2d_scratch__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_scratch/checkpoints/epoch=190-step=95500-loss=0.498.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_MEMB_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml new file mode 100644 index 000000000..152e77d49 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml @@ -0,0 +1,83 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) random-init baseline +# on membrane (Membrane marker), in-focus 2D benchmark track, iPSC +# confocal. Scratch control for the fcmae_vscyto2d_pretrained (VSCyto2D) +# counterpart — the two leaves are identical except this one does NOT load +# pretrained encoder weights. Mirror of the 3D +# membrane/fcmae_vscyto3d_scratch/ipsc_confocal fit leaf. +# +# The 3D ipsc leaf resolves data_path/source_channel/target_channel from +# the manifest via benchmark.dataset_ref, which points at the NON-focus +# cell.zarr. The 2D track reads the offline 5-plane in-focus slab store +# cell_focus.zarr instead, so the resolver is disabled here +# (dataset_ref: null) and the three data fields are declared inline — +# the resolver hook raises on any data.init_args field co-declared with a +# full dataset_ref. source_channel/target_channel reproduce the resolver's +# manifest output (Phase3D / Membrane). +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + train_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch + experiment_id: membrane__ipsc_confocal__fcmae_vscyto2d_scratch + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered cell.zarr. dataset_ref: null makes + # the compose hook a no-op so data fields can be declared inline. + dataset_ref: null + +# Override the FCMAE-2D data overlay's hardcoded `Structure` augmentation +# keys (the overlay was authored for ER/Mito where target_channel == +# "Structure"). RandWeightedCropd needs the actual membrane channel name +# in keys/w_key. spatial_size + num_samples kept identical to the FCMAE-2D +# overlay so the augmentation policy matches ER/Mito. +data: + init_args: + # iPSC in-focus slab store + channels — resolver disabled above. + source_channel: Phase3D + target_channel: Membrane + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Membrane] + w_key: Membrane + spatial_size: [1, 600, 600] + num_samples: 4 + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Scratch_iPSC_Membrane + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_scratch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_scratch/checkpoints + +launcher: + job_name: FCMAE_VSCyto2D_Scratch_Membrane + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_scratch + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..296a3a3f2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: membrane trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-caax-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_denv + model_name: fcmae_vscyto2d_scratch + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_caax_denv + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_denv. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto2d_scratch/checkpoints/epoch=106-step=85600-loss=0.476.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_JOINT_MEMB_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..eeb9cb5ba --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: membrane trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-caax-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_mock + model_name: fcmae_vscyto2d_scratch + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_caax_mock + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_mock. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto2d_scratch/checkpoints/epoch=106-step=85600-loss=0.476.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_JOINT_MEMB_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..4e1c47f6f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: membrane trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-caax-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_zikv + model_name: fcmae_vscyto2d_scratch + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_caax_zikv + # A549 keys membrane by gene (`caax`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_caax_zikv. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto2d_scratch/checkpoints/epoch=106-step=85600-loss=0.476.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_JOINT_MEMB_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..359b7b746 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: membrane trained on joint_ipsc_confocal_a549_mantis, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto2d_scratch/checkpoints/epoch=106-step=85600-loss=0.476.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_JOINT_MEMB_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..6cccb955c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,150 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) random-init baseline +# on membrane (MEMB), in-focus 2D benchmark track — joint ipsc_confocal + +# a549_mantis pooled. Scratch control for the fcmae_vscyto2d_pretrained +# (VSCyto2D) counterpart — the two leaves are identical except this one +# does NOT load pretrained encoder weights. Mirrors +# membrane/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml on the joint +# train_set and the 3D membrane/fcmae_vscyto3d_scratch/joint_* leaf. +# +# Joint leaf: BatchedConcatDataModule + two explicit HCSDataModule +# children; only model_overlays/fcmae_vscyto2d_fit.yml is composed (the +# data overlay is NOT — the data block is inlined via the &hcs_init_args +# anchor). Both children read the offline 5-plane in-focus slab stores +# (z_window_size=1). Single-GPU topology (from the 2D model overlay + +# hardware_gpu_any_long), so no DDP block. +base: + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + gene: Membrane + target: membrane + target_id: membrane + train_set: joint_ipsc_confocal_a549_mantis + model_name: fcmae_vscyto2d_scratch + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Scratch_JOINT_MEMB + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto2d_scratch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto2d_scratch/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Membrane + z_window_size: 1 + # Joint mode does not divide batch_size by num_samples, so 4 * 4 = 16 GPU + # samples per step matches the single-set 2D overlay's effective batch + # (batch_size 16). Halved from the 3D joint's 8 to fit the single-GPU + # 48 GB pool (a40|l40s|a6000) that the 2D track targets. + batch_size: 4 + num_workers: 4 + yx_patch_size: [384, 384] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Membrane] + level: fov_statistics + subtrahend: median + divisor: iqr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Membrane] + w_key: Membrane + spatial_size: [1, 600, 600] + num_samples: 4 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [0, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[1, 1], [0.5, 1.5], [0.5, 1.5]] + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 384, 384] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0, 0] + val_gpu_augmentations: + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 384, 384] + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc multi-marker in-focus slab (Membrane channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + # a549_mantis — pooled dual nucl/memb all-conditions in-focus slab (Membrane channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + +launcher: + job_name: FCMAE_VSCyto2D_Scratch_JOINT_MEMB + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto2d_scratch + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..6a9978cee --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,45 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_denv + model_name: fcmae_vscyto2d_scratch_seed1 + experiment_id: membrane__ipsc_confocal__fcmae_vscyto2d_scratch_seed1__a549_mantis_caax_denv + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_scratch_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/a549__denv/prediction.zarr +launcher: + job_name: FCMAE2D_Scratch_PRED_MEMB_ON_A549_DENV_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..875fa5b80 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,45 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_mock + model_name: fcmae_vscyto2d_scratch_seed1 + experiment_id: membrane__ipsc_confocal__fcmae_vscyto2d_scratch_seed1__a549_mantis_caax_mock + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_scratch_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/a549__mock/prediction.zarr +launcher: + job_name: FCMAE2D_Scratch_PRED_MEMB_ON_A549_MOCK_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..1b1d4279b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,45 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_zikv + model_name: fcmae_vscyto2d_scratch_seed1 + experiment_id: membrane__ipsc_confocal__fcmae_vscyto2d_scratch_seed1__a549_mantis_caax_zikv + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_scratch_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: FCMAE2D_Scratch_PRED_MEMB_ON_A549_ZIKV_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..a48e96775 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,43 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf membrane/fcmae_vscyto2d_scratch/ipsc_confocal/predict__ipsc_confocal.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch_seed1 + experiment_id: membrane__ipsc_confocal__fcmae_vscyto2d_scratch_seed1__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_scratch_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/ipsc/prediction.zarr +launcher: + job_name: FCMAE2D_Scratch_PRED_MEMB_ON_IPSC_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto2d_scratch_seed1/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/train.yml new file mode 100644 index 000000000..4d93b1c0a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/train.yml @@ -0,0 +1,61 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (fit) of the baseline leaf membrane/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml. +# Recipe delta vs that leaf: seed_everything: 1. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/train_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + train_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch_seed1 + experiment_id: membrane__ipsc_confocal__fcmae_vscyto2d_scratch_seed1 + dataset_ref: null +data: + init_args: + source_channel: Phase3D + target_channel: Membrane + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Membrane + w_key: Membrane + spatial_size: + - 1 + - 600 + - 600 + num_samples: 4 +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Scratch_iPSC_Membrane_seed1 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_scratch_seed1 + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: epoch={epoch}-step={step}-loss={loss/validate:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_scratch_seed1/checkpoints +launcher: + job_name: FCMAE_VSCyto2D_Scratch_Membrane_seed1 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto2d_scratch_seed1 + sbatch: + mem: 128G +seed_everything: 1 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_denv.yml index 7af92f328..65c46e0a6 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_denv.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/membrane.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_mock.yml index f79048aa2..b5bb0deee 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_mock.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/membrane.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_zikv.yml index 9669ee930..d5215a4de 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_zikv.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/membrane.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__ipsc_confocal.yml index 3f66b5c62..8a504d9b7 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__ipsc_confocal.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/membrane.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml index 19d3a879b..4d3d0a07b 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml @@ -1,8 +1,8 @@ # FCMAE_VSCyto3D_Pretrained (VSCyto3D) predict: membrane trained on a549_mantis (caax), # predicting against a549-mantis-caax-denv test. -# Best val-loss checkpoint from run 20260522-120713 (epoch 154, loss/validate=0.26533). -# Training reached max_epochs=200; epoch 154 is the global-best val loss (epochs -# 155-199 plateaued higher), so save_top_k kept it as the newest checkpoint. +# Best val-loss checkpoint from run 20260522-120713: epoch 121, loss/validate=0.2651, +# as recorded in last.ckpt's ModelCheckpoint state (monitor loss/validate, mode min) +# and returned by submit_benchmark_job.resolve_best_ckpt. last.ckpt itself is epoch 154. # A549 manifest keys membrane by gene (`caax`); override the iPSC-side `membrane` # target_id from targets/membrane.yml so the resolver finds the caax target on # a549-mantis-caax-denv. @@ -27,7 +27,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fcmae_vscyto3d_pretrained/checkpoints/epoch=154-step=33635.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=121-step=26474.ckpt data: init_args: @@ -44,8 +44,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_a549trained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_A549TR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..b38563909 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_denv_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: membrane__a549_mantis__fcmae_vscyto3d_pretrained__a549_mantis_caax_denv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=121-step=26474.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_A549TR_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml index 5c5c994d7..5c4696d1f 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml @@ -1,8 +1,8 @@ # FCMAE_VSCyto3D_Pretrained (VSCyto3D) predict: membrane trained on a549_mantis (caax), # predicting against a549-mantis-caax-mock test. -# Best val-loss checkpoint from run 20260522-120713 (epoch 154, loss/validate=0.26533). -# Training reached max_epochs=200; epoch 154 is the global-best val loss (epochs -# 155-199 plateaued higher), so save_top_k kept it as the newest checkpoint. +# Best val-loss checkpoint from run 20260522-120713: epoch 121, loss/validate=0.2651, +# as recorded in last.ckpt's ModelCheckpoint state (monitor loss/validate, mode min) +# and returned by submit_benchmark_job.resolve_best_ckpt. last.ckpt itself is epoch 154. # A549 manifest keys membrane by gene (`caax`); override the iPSC-side `membrane` # target_id from targets/membrane.yml so the resolver finds the caax target on # a549-mantis-caax-mock. @@ -27,7 +27,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fcmae_vscyto3d_pretrained/checkpoints/epoch=154-step=33635.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=121-step=26474.ckpt data: init_args: @@ -44,8 +44,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_a549trained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_A549TR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..0943d06c9 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_mock_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: membrane__a549_mantis__fcmae_vscyto3d_pretrained__a549_mantis_caax_mock__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=121-step=26474.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_A549TR_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_movie.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_movie.yml new file mode 100644 index 000000000..9ce2d54b2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_movie.yml @@ -0,0 +1,47 @@ +# VSCyto3D predict: membrane trained on a549_mantis, predicting on the +# cropped A549 TOMM20 DENV movie zarr (125 timepoints). +# No predict_set base — data path set directly to bypass the manifest system. +base: + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_movie + model_name: fcmae_vscyto3d_pretrained + experiment_id: membrane__a549_mantis__fcmae_vscyto3d_pretrained__a549_mantis_movie + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=121-step=26474.ckpt + +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/movie/2024_11_21_A549_TOMM20_DENV_crop.zarr + source_channel: Phase3D + target_channel: Membrane + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + z_window_size: 15 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/a549/movie_predictions/memb_fcmae_vscyto3d_pretrained_a549trained_movie.zarr + +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_A549TR_MOVIE + run_root: /hpc/projects/virtual_staining/training/dynacell/a549/movie_predictions diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml index 4248e142f..ba29d1a08 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml @@ -1,8 +1,8 @@ # FCMAE_VSCyto3D_Pretrained (VSCyto3D) predict: membrane trained on a549_mantis (caax), # predicting against a549-mantis-caax-zikv test. -# Best val-loss checkpoint from run 20260522-120713 (epoch 154, loss/validate=0.26533). -# Training reached max_epochs=200; epoch 154 is the global-best val loss (epochs -# 155-199 plateaued higher), so save_top_k kept it as the newest checkpoint. +# Best val-loss checkpoint from run 20260522-120713: epoch 121, loss/validate=0.2651, +# as recorded in last.ckpt's ModelCheckpoint state (monitor loss/validate, mode min) +# and returned by submit_benchmark_job.resolve_best_ckpt. last.ckpt itself is epoch 154. # A549 manifest keys membrane by gene (`caax`); override the iPSC-side `membrane` # target_id from targets/membrane.yml so the resolver finds the caax target on # a549-mantis-caax-zikv. @@ -27,7 +27,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fcmae_vscyto3d_pretrained/checkpoints/epoch=154-step=33635.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=121-step=26474.ckpt data: init_args: @@ -44,8 +44,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_a549trained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_A549TR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..2a84e1be7 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_zikv_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: membrane__a549_mantis__fcmae_vscyto3d_pretrained__a549_mantis_caax_zikv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=121-step=26474.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_A549TR_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__hek_mantis_kras_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__hek_mantis_kras_a549xy.yml new file mode 100644 index 000000000..b10105e80 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__hek_mantis_kras_a549xy.yml @@ -0,0 +1,48 @@ +# fcmae_vscyto3d_pretrained predict: membrane trained on a549_mantis, +# predicting against the HEK293T third-cell-type probe (KRAS, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'fcmae_vscyto3d_pretrained' (config dir 'fcmae_vscyto3d_pretrained'). +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_kras_a549xy.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: hek_mantis_kras_a549xy + model_name: fcmae_vscyto3d_pretrained + experiment_id: membrane__a549_mantis__fcmae_vscyto3d_pretrained__hek_mantis_kras_a549xy + dataset_ref: + target: kras +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=121-step=26474.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/hek__a549xy/prediction.zarr +launcher: + job_name: VSCYTO3D_PRED_MEMBRANE_A549TR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml index ab1415ab2..4f7060bf8 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml @@ -1,8 +1,8 @@ # FCMAE_VSCyto3D_Pretrained (VSCyto3D) predict: membrane trained on a549_mantis (caax), # predicting against ipsc_confocal test_cropped. -# Best val-loss checkpoint from run 20260522-120713 (epoch 154, loss/validate=0.26533). -# Training reached max_epochs=200; epoch 154 is the global-best val loss (epochs -# 155-199 plateaued higher), so save_top_k kept it as the newest checkpoint. +# Best val-loss checkpoint from run 20260522-120713: epoch 121, loss/validate=0.2651, +# as recorded in last.ckpt's ModelCheckpoint state (monitor loss/validate, mode min) +# and returned by submit_benchmark_job.resolve_best_ckpt. last.ckpt itself is epoch 154. base: - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml - ../../../_internal/shared/model/targets/membrane.yml @@ -21,7 +21,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fcmae_vscyto3d_pretrained/checkpoints/epoch=154-step=33635.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=121-step=26474.ckpt data: init_args: @@ -38,8 +38,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fcmae_vscyto3d_pretrained_a549trained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_A549TR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..ede4ef4e0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: ipsc_confocal_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: membrane__a549_mantis__fcmae_vscyto3d_pretrained__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=121-step=26474.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_A549TR_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/train.yml index af89bcacb..bdfbbd474 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/a549_mantis/train.yml @@ -49,7 +49,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Pretrained_A549_Membrane - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fcmae_vscyto3d_pretrained + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_pretrained callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -57,11 +57,13 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fcmae_vscyto3d_pretrained/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_pretrained/checkpoints launcher: job_name: FCMAE_VSCyto3D_Pretrained_A549_Membrane - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fcmae_vscyto3d_pretrained + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_pretrained diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index c2e04cb76..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Membrane (CAAX) predicted by FCMAE_VSCyto3D_Pretrained on a549-mantis-caax-denv. -# A549 manifest keys membrane by gene (`caax`); override the iPSC-side `membrane` -# target_id from the target group so the resolver finds caax on a549-mantis-caax-denv. -defaults: - - override /target: membrane - - override /predict_set: a549_mantis_caax_denv - -benchmark: - dataset_ref: - target: caax - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_memb_fcmae_vscyto3d_pretrained_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index e6c9da7f2..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Membrane (CAAX) predicted by FCMAE_VSCyto3D_Pretrained on a549-mantis-caax-mock. -# A549 manifest keys membrane by gene (`caax`); override the iPSC-side `membrane` -# target_id from the target group so the resolver finds caax on a549-mantis-caax-mock. -defaults: - - override /target: membrane - - override /predict_set: a549_mantis_caax_mock - -benchmark: - dataset_ref: - target: caax - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_memb_fcmae_vscyto3d_pretrained_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index 7f7fbfb5d..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Membrane (CAAX) predicted by FCMAE_VSCyto3D_Pretrained on a549-mantis-caax-zikv. -# A549 manifest keys membrane by gene (`caax`); override the iPSC-side `membrane` -# target_id from the target group so the resolver finds caax on a549-mantis-caax-zikv. -defaults: - - override /target: membrane - - override /predict_set: a549_mantis_caax_zikv - -benchmark: - dataset_ref: - target: caax - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_memb_fcmae_vscyto3d_pretrained_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml index 2ddbbc193..efc3b9d98 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml @@ -24,7 +24,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fcmae_vscyto3d_pretrained/checkpoints/epoch=189-step=59280.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=189-step=59280.ckpt data: init_args: @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_ON_A549_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..0d6a31b97 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_denv_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: membrane__ipsc_confocal__fcmae_vscyto3d_pretrained__a549_mantis_caax_denv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=189-step=59280.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_ON_A549_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml index 61cffffc1..f6cab8473 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml @@ -24,7 +24,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fcmae_vscyto3d_pretrained/checkpoints/epoch=189-step=59280.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=189-step=59280.ckpt data: init_args: @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_ON_A549_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..21bbb0a94 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_mock_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: membrane__ipsc_confocal__fcmae_vscyto3d_pretrained__a549_mantis_caax_mock__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=189-step=59280.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_ON_A549_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml index 844934d41..f43f2bf95 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -24,7 +24,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fcmae_vscyto3d_pretrained/checkpoints/epoch=189-step=59280.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=189-step=59280.ckpt data: init_args: @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_ON_A549_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..d9dd7e9d7 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_zikv_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: membrane__ipsc_confocal__fcmae_vscyto3d_pretrained__a549_mantis_caax_zikv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=189-step=59280.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_ON_A549_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__hek_mantis_kras_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__hek_mantis_kras_a549xy.yml new file mode 100644 index 000000000..908f24fb2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__hek_mantis_kras_a549xy.yml @@ -0,0 +1,48 @@ +# fcmae_vscyto3d_pretrained predict: membrane trained on ipsc_confocal, +# predicting against the HEK293T third-cell-type probe (KRAS, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'fcmae_vscyto3d_pretrained' (config dir 'fcmae_vscyto3d_pretrained'). +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_kras_a549xy.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: hek_mantis_kras_a549xy + model_name: fcmae_vscyto3d_pretrained + experiment_id: membrane__ipsc_confocal__fcmae_vscyto3d_pretrained__hek_mantis_kras_a549xy + dataset_ref: + target: kras +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=189-step=59280.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/hek__a549xy/prediction.zarr +launcher: + job_name: VSCYTO3D_PRED_MEMBRANE_IPSCTR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml index 32093aacd..a795dc3b5 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fcmae_vscyto3d_pretrained/checkpoints/epoch=189-step=59280.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=189-step=59280.ckpt data: init_args: @@ -34,8 +34,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fcmae_vscyto3d_pretrained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..7ebc1a5fc --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: membrane__ipsc_confocal__fcmae_vscyto3d_pretrained__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=189-step=59280.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_pretrained/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/train.yml index 4fb87dd32..26892396a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/ipsc_confocal/train.yml @@ -46,7 +46,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Pretrained_iPSC_Membrane - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fcmae_vscyto3d_pretrained + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_pretrained callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -54,11 +54,13 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fcmae_vscyto3d_pretrained/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_pretrained/checkpoints launcher: job_name: FCMAE_VSCyto3D_Pretrained_Membrane - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fcmae_vscyto3d_pretrained + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_pretrained diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index 60fe4a0f1..95a4020c5 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fcmae_vscyto3d_pretrained/checkpoints/epoch=111-step=59360.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=148-step=78970-loss=0.374.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_jointtrained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_JOINTTR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index 176cf777b..58d31e400 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fcmae_vscyto3d_pretrained/checkpoints/epoch=111-step=59360.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=148-step=78970-loss=0.374.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_jointtrained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_JOINTTR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index 1e3ae6171..da582fc04 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fcmae_vscyto3d_pretrained/checkpoints/epoch=111-step=59360.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=148-step=78970-loss=0.374.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_pretrained_jointtrained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_JOINTTR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_kras_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_kras_a549xy.yml new file mode 100644 index 000000000..b301a7615 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_kras_a549xy.yml @@ -0,0 +1,48 @@ +# fcmae_vscyto3d_pretrained predict: membrane trained on joint_ipsc_confocal_a549_mantis, +# predicting against the HEK293T third-cell-type probe (KRAS, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'fcmae_vscyto3d_pretrained' (config dir 'fcmae_vscyto3d_pretrained'). +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_kras_a549xy.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: hek_mantis_kras_a549xy + model_name: fcmae_vscyto3d_pretrained + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__fcmae_vscyto3d_pretrained__hek_mantis_kras_a549xy + dataset_ref: + target: kras +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=148-step=78970-loss=0.374.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/hek__a549xy/prediction.zarr +launcher: + job_name: VSCYTO3D_PRED_MEMBRANE_JOINTTR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index babf7d9e9..ae17d643a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -21,7 +21,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fcmae_vscyto3d_pretrained/checkpoints/epoch=111-step=59360.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto3d_pretrained/checkpoints/epoch=148-step=78970-loss=0.374.ckpt data: init_args: @@ -38,8 +38,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fcmae_vscyto3d_pretrained_jointtrained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_MEMB_JOINTTR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_pretrained/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml index 9e543f5b1..def739ebc 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml @@ -22,7 +22,7 @@ base: - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_fit.yml - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu_long.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -46,7 +46,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Pretrained_JOINT_MEMB - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fcmae_vscyto3d_pretrained + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto3d_pretrained callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -54,10 +54,12 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fcmae_vscyto3d_pretrained/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto3d_pretrained/checkpoints _hcs_init_args: &hcs_init_args source_channel: Phase3D @@ -151,4 +153,4 @@ data: launcher: job_name: FCMAE_VSCyto3D_Pretrained_JOINT_MEMB - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fcmae_vscyto3d_pretrained + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto3d_pretrained diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml index be27c8afc..bac36c4db 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fcmae_vscyto3d_scratch/checkpoints/epoch=119-step=26040.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=119-step=26040.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_a549trained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB_A549TR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..0b24e431b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_denv_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: membrane__a549_mantis__fcmae_vscyto3d_scratch__a549_mantis_caax_denv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=119-step=26040.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB_A549TR_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml index d63edd3ea..f3301113c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fcmae_vscyto3d_scratch/checkpoints/epoch=119-step=26040.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=119-step=26040.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_a549trained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB_A549TR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..99c74edc9 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_mock_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: membrane__a549_mantis__fcmae_vscyto3d_scratch__a549_mantis_caax_mock__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=119-step=26040.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB_A549TR_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml index 5521558ae..24228b7a4 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fcmae_vscyto3d_scratch/checkpoints/epoch=119-step=26040.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=119-step=26040.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_a549trained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB_A549TR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..1f5343072 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_zikv_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: membrane__a549_mantis__fcmae_vscyto3d_scratch__a549_mantis_caax_zikv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=119-step=26040.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB_A549TR_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml index 821ab2335..52dd860fb 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml @@ -19,7 +19,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fcmae_vscyto3d_scratch/checkpoints/epoch=119-step=26040.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=119-step=26040.ckpt data: init_args: @@ -36,8 +36,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fcmae_vscyto3d_scratch_a549trained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB_A549TR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..d06cc7195 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: ipsc_confocal_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: membrane__a549_mantis__fcmae_vscyto3d_scratch__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=119-step=26040.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB_A549TR_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/train.yml index a01a7175d..a20c28e97 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/a549_mantis/train.yml @@ -41,7 +41,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Scratch_A549_Membrane - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fcmae_vscyto3d_scratch + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_scratch callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -49,11 +49,13 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fcmae_vscyto3d_scratch/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_scratch/checkpoints launcher: job_name: FCMAE_VSCyto3D_Scratch_A549_Membrane - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fcmae_vscyto3d_scratch + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fcmae_vscyto3d_scratch diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index 8d6185031..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Membrane (CAAX) predicted by FCMAE_VSCyto3D_Scratch on a549-mantis-caax-denv. -# A549 manifest keys membrane by gene (`caax`); override the iPSC-side `membrane` -# target_id from the target group so the resolver finds caax on a549-mantis-caax-denv. -defaults: - - override /target: membrane - - override /predict_set: a549_mantis_caax_denv - -benchmark: - dataset_ref: - target: caax - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_memb_fcmae_vscyto3d_scratch_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index b42b6d474..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Membrane (CAAX) predicted by FCMAE_VSCyto3D_Scratch on a549-mantis-caax-mock. -# A549 manifest keys membrane by gene (`caax`); override the iPSC-side `membrane` -# target_id from the target group so the resolver finds caax on a549-mantis-caax-mock. -defaults: - - override /target: membrane - - override /predict_set: a549_mantis_caax_mock - -benchmark: - dataset_ref: - target: caax - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_memb_fcmae_vscyto3d_scratch_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index e8de39923..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Membrane (CAAX) predicted by FCMAE_VSCyto3D_Scratch on a549-mantis-caax-zikv. -# A549 manifest keys membrane by gene (`caax`); override the iPSC-side `membrane` -# target_id from the target group so the resolver finds caax on a549-mantis-caax-zikv. -defaults: - - override /target: membrane - - override /predict_set: a549_mantis_caax_zikv - -benchmark: - dataset_ref: - target: caax - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_memb_fcmae_vscyto3d_scratch_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml index 3f975a14b..3cc402a57 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml @@ -34,7 +34,7 @@ model: # by 4.3%; prefer the pretrained predict configs for downstream eval. # Hardlink alias at run_root; underlying epoch=136-step=42744.ckpt also # preserved in checkpoints_frozen_ep136_20260501_005505/. - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fcmae_vscyto3d_scratch/best_ep136_val0.39590.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=136-step=42744.ckpt data: init_args: @@ -51,8 +51,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB_ON_A549_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..2a844d903 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_denv_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: membrane__ipsc_confocal__fcmae_vscyto3d_scratch__a549_mantis_caax_denv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=136-step=42744.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB_ON_A549_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml index e7a79de69..8a2aad34e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml @@ -34,7 +34,7 @@ model: # by 4.3%; prefer the pretrained predict configs for downstream eval. # Hardlink alias at run_root; underlying epoch=136-step=42744.ckpt also # preserved in checkpoints_frozen_ep136_20260501_005505/. - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fcmae_vscyto3d_scratch/best_ep136_val0.39590.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=136-step=42744.ckpt data: init_args: @@ -51,8 +51,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB_ON_A549_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..9d9695a5e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_mock_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: membrane__ipsc_confocal__fcmae_vscyto3d_scratch__a549_mantis_caax_mock__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=136-step=42744.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB_ON_A549_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml index 53a090a83..def14ac39 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -34,7 +34,7 @@ model: # by 4.3%; prefer the pretrained predict configs for downstream eval. # Hardlink alias at run_root; underlying epoch=136-step=42744.ckpt also # preserved in checkpoints_frozen_ep136_20260501_005505/. - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fcmae_vscyto3d_scratch/best_ep136_val0.39590.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=136-step=42744.ckpt data: init_args: @@ -51,8 +51,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB_ON_A549_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..bf6060b53 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_zikv_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: membrane__ipsc_confocal__fcmae_vscyto3d_scratch__a549_mantis_caax_zikv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=136-step=42744.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB_ON_A549_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml index 1d430ba9e..c2046bc00 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml @@ -27,7 +27,7 @@ model: # by 4.3%; prefer the pretrained predict configs for downstream eval. # Hardlink alias at run_root; underlying epoch=136-step=42744.ckpt also # preserved in checkpoints_frozen_ep136_20260501_005505/. - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fcmae_vscyto3d_scratch/best_ep136_val0.39590.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=136-step=42744.ckpt data: init_args: @@ -44,8 +44,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fcmae_vscyto3d_scratch.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..e5963daa9 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: membrane__ipsc_confocal__fcmae_vscyto3d_scratch__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=136-step=42744.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fcmae_vscyto3d_scratch/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/train.yml index 5b5c2866e..3973b0798 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/ipsc_confocal/train.yml @@ -38,7 +38,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Scratch_iPSC_Membrane - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fcmae_vscyto3d_scratch + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_scratch callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -46,11 +46,13 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fcmae_vscyto3d_scratch/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_scratch/checkpoints launcher: job_name: FCMAE_VSCyto3D_Scratch_Membrane - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fcmae_vscyto3d_scratch + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fcmae_vscyto3d_scratch diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index fd69b738d..06889a606 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fcmae_vscyto3d_scratch/checkpoints/epoch=112-step=59890.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=172-step=91690-loss=0.381.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_jointtrained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB_JOINTTR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index 3dc88f5a9..246d759c9 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fcmae_vscyto3d_scratch/checkpoints/epoch=112-step=59890.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=172-step=91690-loss=0.381.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_jointtrained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB_JOINTTR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index 2fc00ab64..ca5e81110 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fcmae_vscyto3d_scratch/checkpoints/epoch=112-step=59890.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=172-step=91690-loss=0.381.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fcmae_vscyto3d_scratch_jointtrained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB_JOINTTR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index 2cfeaa4a8..4017f0be4 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -21,7 +21,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fcmae_vscyto3d_scratch/checkpoints/epoch=112-step=59890.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto3d_scratch/checkpoints/epoch=172-step=91690-loss=0.381.ckpt data: init_args: @@ -38,8 +38,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fcmae_vscyto3d_scratch_jointtrained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_MEMB_JOINTTR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fcmae_vscyto3d_scratch/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/train.yml index 15d247bf7..d020ec1e8 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/train.yml @@ -17,7 +17,7 @@ base: - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_fit.yml - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu_long.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -34,7 +34,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Scratch_JOINT_MEMB - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fcmae_vscyto3d_scratch + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto3d_scratch callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -42,10 +42,12 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fcmae_vscyto3d_scratch/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto3d_scratch/checkpoints _hcs_init_args: &hcs_init_args source_channel: Phase3D @@ -139,4 +141,4 @@ data: launcher: job_name: FCMAE_VSCyto3D_Scratch_JOINT_MEMB - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fcmae_vscyto3d_scratch + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fcmae_vscyto3d_scratch diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..f9b591958 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,55 @@ +# FNet2D predict: membrane (MEMB) trained on a549_mantis, tested on A549 mantis denv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=963-step=192800-loss=0.811.ckpt (loss/validate=0.811). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_denv + model_name: fnet2d + experiment_id: membrane__a549_mantis__fnet2d__a549_mantis_caax_denv + # Override the iPSC-side `membrane` target with a549's gene-keyed `caax`. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fnet2d/checkpoints/epoch=963-step=192800-loss=0.811.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__denv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_MEMB_A549TR_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..1d8117f3e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,55 @@ +# FNet2D predict: membrane (MEMB) trained on a549_mantis, tested on A549 mantis mock. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=963-step=192800-loss=0.811.ckpt (loss/validate=0.811). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_mock + model_name: fnet2d + experiment_id: membrane__a549_mantis__fnet2d__a549_mantis_caax_mock + # Override the iPSC-side `membrane` target with a549's gene-keyed `caax`. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fnet2d/checkpoints/epoch=963-step=192800-loss=0.811.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__mock/prediction.zarr + +launcher: + job_name: FNet2D_PRED_MEMB_A549TR_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..1ccdebdca --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,55 @@ +# FNet2D predict: membrane (MEMB) trained on a549_mantis, tested on A549 mantis zikv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=963-step=192800-loss=0.811.ckpt (loss/validate=0.811). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_zikv + model_name: fnet2d + experiment_id: membrane__a549_mantis__fnet2d__a549_mantis_caax_zikv + # Override the iPSC-side `membrane` target with a549's gene-keyed `caax`. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fnet2d/checkpoints/epoch=963-step=192800-loss=0.811.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__zikv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_MEMB_A549TR_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..d6eca3421 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,52 @@ +# FNet2D predict: membrane (MEMB) trained on a549_mantis, tested on iPSC confocal. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=963-step=192800-loss=0.811.ckpt (loss/validate=0.811). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: fnet2d + experiment_id: membrane__a549_mantis__fnet2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fnet2d/checkpoints/epoch=963-step=192800-loss=0.811.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/ipsc/prediction.zarr + +launcher: + job_name: FNet2D_PRED_MEMB_A549TR + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/train.yml new file mode 100644 index 000000000..e72cad86e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/a549_mantis/train.yml @@ -0,0 +1,84 @@ +# FNet2D (FNet3D run Z-preserving at Z=1) fit on membrane (Membrane channel) +# — A549 mantis-lightsheet pooled (mock + DENV + ZIKV), in-focus 2D track. +# Mirror of the 3D membrane/fnet3d_paper/a549_mantis fit leaf, flattened onto +# the offline 5-plane in-focus slab store dual_nucl_memb_all_focus.zarr +# (z_window_size=1 emits one in-focus window per plane). +# +# The fnet2d data overlay keys norm/aug/val_aug on Structure (the ER/Mito +# target). Membrane target_channel is Membrane, so we list-replace those +# three lists here to re-key them, flattening the crops [32,64,64] -> [1,64,64]. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/data_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + train_set: a549_mantis + model_name: fnet2d + experiment_id: membrane__a549_mantis__fnet2d + +data: + init_args: + # A549 pooled in-focus slab store + target_channel — no resolver in this + # train_set. Nucleus + membrane share dual_nucl_memb_all_focus.zarr. + target_channel: Membrane + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Membrane] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Membrane] + w_key: Membrane + spatial_size: [1, 64, 64] + num_samples: 8 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Phase3D, Membrane] + roi_size: [1, 64, 64] + +trainer: + logger: + init_args: + name: FNet2D_A549_MEMB + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fnet2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fnet2d/checkpoints + +launcher: + job_name: FNet2D_A549_MEMB + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fnet2d + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D store + # (~1/4 the Z), so the 512G headroom the 3D leaf needed for mmap_preload + # is wasteful and delays scheduling. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..95523d72a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,55 @@ +# FNet2D predict: membrane (MEMB) trained on ipsc_confocal, tested on A549 mantis denv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=437-step=145854-loss=0.641.ckpt (loss/validate=0.641). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_denv + model_name: fnet2d + experiment_id: membrane__ipsc_confocal__fnet2d__a549_mantis_caax_denv + # Override the iPSC-side `membrane` target with a549's gene-keyed `caax`. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet2d/checkpoints/epoch=437-step=145854-loss=0.641.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_MEMB_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..67c378191 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,55 @@ +# FNet2D predict: membrane (MEMB) trained on ipsc_confocal, tested on A549 mantis mock. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=437-step=145854-loss=0.641.ckpt (loss/validate=0.641). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_mock + model_name: fnet2d + experiment_id: membrane__ipsc_confocal__fnet2d__a549_mantis_caax_mock + # Override the iPSC-side `membrane` target with a549's gene-keyed `caax`. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet2d/checkpoints/epoch=437-step=145854-loss=0.641.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: FNet2D_PRED_MEMB_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..4d8f3e557 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,55 @@ +# FNet2D predict: membrane (MEMB) trained on ipsc_confocal, tested on A549 mantis zikv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=437-step=145854-loss=0.641.ckpt (loss/validate=0.641). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_zikv + model_name: fnet2d + experiment_id: membrane__ipsc_confocal__fnet2d__a549_mantis_caax_zikv + # Override the iPSC-side `membrane` target with a549's gene-keyed `caax`. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet2d/checkpoints/epoch=437-step=145854-loss=0.641.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_MEMB_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..9ea5836a2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,52 @@ +# FNet2D predict: membrane (MEMB) trained on ipsc_confocal, tested on iPSC confocal. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=437-step=145854-loss=0.641.ckpt (loss/validate=0.641). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fnet2d + experiment_id: membrane__ipsc_confocal__fnet2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet2d/checkpoints/epoch=437-step=145854-loss=0.641.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/ipsc/prediction.zarr + +launcher: + job_name: FNet2D_PRED_MEMB + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/train.yml new file mode 100644 index 000000000..d15461f80 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/ipsc_confocal/train.yml @@ -0,0 +1,96 @@ +# FNet2D (FNet3D run Z-preserving at Z=1) fit on membrane (Membrane channel) +# — AICS iPSC confocal, in-focus 2D track. Mirror of the 3D +# membrane/fnet3d_paper/ipsc_confocal fit leaf, flattened onto the offline +# 5-plane in-focus slab store cell_focus.zarr (z_window_size=1 emits one +# in-focus window per plane). +# +# The 3D ipsc leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus +# cell.zarr. The 2D track reads cell_focus.zarr instead, so the resolver is +# disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field co-declared +# with a full dataset_ref. source_channel/target_channel reproduce the +# resolver's manifest output (Phase3D / Membrane). +# +# The fnet2d data overlay keys norm/aug/val_aug on Structure (the ER/Mito +# target), so we list-replace those three lists here to re-key to Membrane, +# flattening the crops [32,64,64] -> [1,64,64]. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/data_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + train_set: ipsc_confocal + model_name: fnet2d + experiment_id: membrane__ipsc_confocal__fnet2d + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered cell.zarr. dataset_ref: null makes + # the compose hook a no-op so data fields can be declared inline. + dataset_ref: null + +data: + init_args: + # iPSC in-focus slab store + channels — resolver disabled above. + source_channel: Phase3D + target_channel: Membrane + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Membrane] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Membrane] + w_key: Membrane + spatial_size: [1, 64, 64] + num_samples: 8 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Phase3D, Membrane] + roi_size: [1, 64, 64] + +trainer: + logger: + init_args: + name: FNet2D_iPSC_MEMB + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet2d/checkpoints + +launcher: + job_name: FNet2D_MEMB + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet2d + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D store + # (~1/4 the Z), so the 512G headroom the 3D leaf needed for cell.zarr + # mmap_preload is wasteful and delays scheduling. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..11e63c2b1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,55 @@ +# FNet2D predict: membrane (MEMB) trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis denv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=369-step=197210-loss=0.707.ckpt (loss/validate=0.707). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_denv + model_name: fnet2d + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__fnet2d__a549_mantis_caax_denv + # Override the iPSC-side `membrane` target with a549's gene-keyed `caax`. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fnet2d/checkpoints/epoch=369-step=197210-loss=0.707.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__denv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_MEMB_JOINTTR_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..3db2c742c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,55 @@ +# FNet2D predict: membrane (MEMB) trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis mock. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=369-step=197210-loss=0.707.ckpt (loss/validate=0.707). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_mock + model_name: fnet2d + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__fnet2d__a549_mantis_caax_mock + # Override the iPSC-side `membrane` target with a549's gene-keyed `caax`. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fnet2d/checkpoints/epoch=369-step=197210-loss=0.707.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__mock/prediction.zarr + +launcher: + job_name: FNet2D_PRED_MEMB_JOINTTR_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..668267e31 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,55 @@ +# FNet2D predict: membrane (MEMB) trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis zikv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=369-step=197210-loss=0.707.ckpt (loss/validate=0.707). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_zikv + model_name: fnet2d + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__fnet2d__a549_mantis_caax_zikv + # Override the iPSC-side `membrane` target with a549's gene-keyed `caax`. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fnet2d/checkpoints/epoch=369-step=197210-loss=0.707.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__zikv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_MEMB_JOINTTR_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..ab8f7dfc8 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,52 @@ +# FNet2D predict: membrane (MEMB) trained on joint_ipsc_confocal_a549_mantis, tested on iPSC confocal. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=369-step=197210-loss=0.707.ckpt (loss/validate=0.707). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: fnet2d + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__fnet2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fnet2d/checkpoints/epoch=369-step=197210-loss=0.707.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/ipsc/prediction.zarr + +launcher: + job_name: FNet2D_PRED_MEMB_JOINTTR + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..41493d177 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,123 @@ +# FNet2D (FNet3D run Z-preserving at Z=1) fit on membrane (MEMB) — joint +# ipsc_confocal + a549_mantis pooled, in-focus 2D track. Mirror of the 3D +# membrane/fnet3d_paper/joint_* fit leaf, flattened onto the offline 5-plane +# in-focus slab stores (z_window_size=1 emits one in-focus window per plane). +# +# BatchedConcatDataModule + two explicit HCSDataModule children; only +# model_overlays/fnet2d_fit.yml is composed (the data block is authored +# inline here, not via data_overlays). Norms + 8-crops-per-FOV diverge from +# the CellDiff/UNetViT conventions: target channel uses mean/std (not +# median/iqr) and val augmentations are CPU CenterSpatialCropd on the raw +# keys. Crops flattened [32,64,64] -> [1,64,64], z_window_size 32 -> 1. +# +# Topology: single GPU, any model, long wall — same as the 3D FNet paper +# baseline, kept so iPSC-only and joint runs are apples-to-apples. +base: + - ../../../_internal/shared/model/model_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + gene: Membrane + target: membrane + target_id: membrane + train_set: joint_ipsc_confocal_a549_mantis + model_name: fnet2d + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__fnet2d + +trainer: + logger: + init_args: + name: FNet2D_JOINT_MEMB + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fnet2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fnet2d/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Membrane + z_window_size: 1 + # See nucleus/fnet2d/joint_*/train.yml for the rationale: joint mode does + # not divide batch_size by num_samples (unlike single-set), so + # 6 * num_samples=8 = 48 GPU samples matches single-set effective. + batch_size: 6 + num_workers: 8 + yx_patch_size: [64, 64] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Membrane] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Membrane] + w_key: Membrane + spatial_size: [1, 64, 64] + num_samples: 8 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandFlipd + init_args: + keys: [source, target] + spatial_axes: [1] + prob: 0.5 + - class_path: viscy_transforms.BatchedRandFlipd + init_args: + keys: [source, target] + spatial_axes: [2] + prob: 0.5 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Phase3D, Membrane] + roi_size: [1, 64, 64] + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc in-focus slab store (Membrane channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + # a549_mantis — pooled dual nucl+memb in-focus slab store (Membrane channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + +launcher: + job_name: FNet2D_JOINT_MEMB + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fnet2d + # 128G: the in-focus slab stores are 5-plane slices of the full-Z 3D + # stores (~1/4 the Z), so the 512G headroom the 3D joint leaf needed for + # dual mmap_preload is wasteful and delays scheduling. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..bc7dc9b99 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,45 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf membrane/fnet2d/ipsc_confocal/predict__a549_mantis_denv.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_denv + model_name: fnet2d_seed1 + experiment_id: membrane__ipsc_confocal__fnet2d_seed1__a549_mantis_caax_denv + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet2d_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d_seed1/ipsc/a549__denv/prediction.zarr +launcher: + job_name: FNet2D_PRED_MEMB_DENV_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d_seed1/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..70c0366ee --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,45 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf membrane/fnet2d/ipsc_confocal/predict__a549_mantis_mock.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_mock + model_name: fnet2d_seed1 + experiment_id: membrane__ipsc_confocal__fnet2d_seed1__a549_mantis_caax_mock + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet2d_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d_seed1/ipsc/a549__mock/prediction.zarr +launcher: + job_name: FNet2D_PRED_MEMB_MOCK_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d_seed1/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..380a0ef2e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,45 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf membrane/fnet2d/ipsc_confocal/predict__a549_mantis_zikv.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_zikv + model_name: fnet2d_seed1 + experiment_id: membrane__ipsc_confocal__fnet2d_seed1__a549_mantis_caax_zikv + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet2d_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d_seed1/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: FNet2D_PRED_MEMB_ZIKV_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d_seed1/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..c9d83648f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,43 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf membrane/fnet2d/ipsc_confocal/predict__ipsc_confocal.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fnet2d_seed1 + experiment_id: membrane__ipsc_confocal__fnet2d_seed1__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet2d_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d_seed1/ipsc/ipsc/prediction.zarr +launcher: + job_name: FNet2D_PRED_MEMB_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet2d_seed1/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/train.yml new file mode 100644 index 000000000..cb2626688 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet2d_seed1/ipsc_confocal/train.yml @@ -0,0 +1,86 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (fit) of the baseline leaf membrane/fnet2d/ipsc_confocal/train.yml. +# Recipe delta vs that leaf: seed_everything: 1. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/train_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/data_overlays/fnet2d_fit.yml +- ../../../_internal/shared/model/model_overlays/fnet2d_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + train_set: ipsc_confocal + model_name: fnet2d_seed1 + experiment_id: membrane__ipsc_confocal__fnet2d_seed1 + dataset_ref: null +data: + init_args: + source_channel: Phase3D + target_channel: Membrane + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Membrane + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Membrane + w_key: Membrane + spatial_size: + - 1 + - 64 + - 64 + num_samples: 8 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: + - Phase3D + - Membrane + roi_size: + - 1 + - 64 + - 64 +trainer: + logger: + init_args: + name: FNet2D_iPSC_MEMB_seed1 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet2d_seed1 + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: epoch={epoch}-step={step}-loss={loss/validate:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet2d_seed1/checkpoints +launcher: + job_name: FNet2D_MEMB_seed1 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet2d_seed1 + sbatch: + mem: 128G +seed_everything: 1 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml index dda0e1612..88abfd1d4 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fnet3d_paper/checkpoints/epoch=281-step=191760.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fnet3d_paper/checkpoints/epoch=281-step=191760.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_a549trained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/a549__denv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_MEMB_A549TR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..578b18e18 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_denv_lite + model_name: fnet3d_paper + experiment_id: membrane__a549_mantis__fnet3d_paper__a549_mantis_caax_denv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fnet3d_paper/checkpoints/epoch=281-step=191760.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/a549/a549__denv/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_MEMB_A549TR_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml index a6a0299a8..c4ce850bb 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fnet3d_paper/checkpoints/epoch=281-step=191760.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fnet3d_paper/checkpoints/epoch=281-step=191760.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_a549trained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/a549__mock/prediction.zarr launcher: job_name: FNet3DPaper_PRED_MEMB_A549TR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..e9099d155 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_mock_lite + model_name: fnet3d_paper + experiment_id: membrane__a549_mantis__fnet3d_paper__a549_mantis_caax_mock__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fnet3d_paper/checkpoints/epoch=281-step=191760.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/a549/a549__mock/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_MEMB_A549TR_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml index f7bad7715..eae40dbf7 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fnet3d_paper/checkpoints/epoch=281-step=191760.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fnet3d_paper/checkpoints/epoch=281-step=191760.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_a549trained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/a549__zikv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_MEMB_A549TR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..166fd6c32 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_zikv_lite + model_name: fnet3d_paper + experiment_id: membrane__a549_mantis__fnet3d_paper__a549_mantis_caax_zikv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fnet3d_paper/checkpoints/epoch=281-step=191760.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/a549/a549__zikv/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_MEMB_A549TR_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__hek_mantis_kras_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__hek_mantis_kras_a549xy.yml new file mode 100644 index 000000000..24c9ff126 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__hek_mantis_kras_a549xy.yml @@ -0,0 +1,48 @@ +# fnet3d_paper predict: membrane trained on a549_mantis, +# predicting against the HEK293T third-cell-type probe (KRAS, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# membrane/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'fnet3d_paper' (config dir 'fnet3d_paper'). +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_kras_a549xy.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: hek_mantis_kras_a549xy + model_name: fnet3d_paper + experiment_id: membrane__a549_mantis__fnet3d_paper__hek_mantis_kras_a549xy + dataset_ref: + target: kras +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fnet3d_paper/checkpoints/epoch=281-step=191760.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/hek__a549xy/prediction.zarr +launcher: + job_name: FNET3D_PRED_MEMBRANE_A549TR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml index 3f24aba59..ca7e87755 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml @@ -19,7 +19,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fnet3d_paper/checkpoints/epoch=281-step=191760.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fnet3d_paper/checkpoints/epoch=281-step=191760.ckpt data: init_args: @@ -36,8 +36,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fnet3d_paper_a549trained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/ipsc/prediction.zarr launcher: job_name: FNet3DPaper_PRED_MEMB_A549TR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..6a1c6eb60 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: ipsc_confocal_lite + model_name: fnet3d_paper + experiment_id: membrane__a549_mantis__fnet3d_paper__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fnet3d_paper/checkpoints/epoch=281-step=191760.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/a549/ipsc/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_MEMB_A549TR_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/train.yml index f1ccc4a5f..83cd37e9a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/a549_mantis/train.yml @@ -53,7 +53,7 @@ trainer: logger: init_args: name: FNet3D_A549_MEMB_paper - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fnet3d_paper + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fnet3d_paper callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -61,14 +61,16 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fnet3d_paper/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fnet3d_paper/checkpoints launcher: job_name: FNet3DPaper_A549_MEMB - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/memb/fnet3d_paper + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/fnet3d_paper # 512G to match the shared headroom convention across the fnet3d # leaves on a549/joint workloads. mmap_preload after the BasicIndexer # fix peaks at ~75 GB for CAAX_all alone (single-set); 512G gives diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index 7c0b1a626..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Membrane (CAAX) predicted by FNet3DPaper on a549-mantis-caax-denv. -# A549 manifest keys membrane by gene (`caax`); override the iPSC-side `membrane` -# target_id from the target group so the resolver finds caax on a549-mantis-caax-denv. -defaults: - - override /target: membrane - - override /predict_set: a549_mantis_caax_denv - -benchmark: - dataset_ref: - target: caax - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_memb_fnet3d_paper_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index a25066d99..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Membrane (CAAX) predicted by FNet3DPaper on a549-mantis-caax-mock. -# A549 manifest keys membrane by gene (`caax`); override the iPSC-side `membrane` -# target_id from the target group so the resolver finds caax on a549-mantis-caax-mock. -defaults: - - override /target: membrane - - override /predict_set: a549_mantis_caax_mock - -benchmark: - dataset_ref: - target: caax - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_memb_fnet3d_paper_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index b2333dc20..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Membrane (CAAX) predicted by FNet3DPaper on a549-mantis-caax-zikv. -# A549 manifest keys membrane by gene (`caax`); override the iPSC-side `membrane` -# target_id from the target group so the resolver finds caax on a549-mantis-caax-zikv. -defaults: - - override /target: membrane - - override /predict_set: a549_mantis_caax_zikv - -benchmark: - dataset_ref: - target: caax - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_memb_fnet3d_paper_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml index a7aef7680..a4e00c636 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml @@ -24,7 +24,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fnet3d_paper/checkpoints/epoch=181-step=157612.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet3d_paper/checkpoints/epoch=181-step=157612.ckpt data: init_args: @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/a549__denv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_MEMB_ON_A549_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..37ff45f12 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_denv_lite + model_name: fnet3d_paper + experiment_id: membrane__ipsc_confocal__fnet3d_paper__a549_mantis_caax_denv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet3d_paper/checkpoints/epoch=181-step=157612.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/ipsc/a549__denv/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_MEMB_ON_A549_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml index 515c2d253..882396260 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml @@ -24,7 +24,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fnet3d_paper/checkpoints/epoch=181-step=157612.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet3d_paper/checkpoints/epoch=181-step=157612.ckpt data: init_args: @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/a549__mock/prediction.zarr launcher: job_name: FNet3DPaper_PRED_MEMB_ON_A549_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..27a548654 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_mock_lite + model_name: fnet3d_paper + experiment_id: membrane__ipsc_confocal__fnet3d_paper__a549_mantis_caax_mock__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet3d_paper/checkpoints/epoch=181-step=157612.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/ipsc/a549__mock/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_MEMB_ON_A549_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml index 9af57720b..665197a79 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -24,7 +24,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fnet3d_paper/checkpoints/epoch=181-step=157612.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet3d_paper/checkpoints/epoch=181-step=157612.ckpt data: init_args: @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/a549__zikv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_MEMB_ON_A549_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..87f899a0c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_zikv_lite + model_name: fnet3d_paper + experiment_id: membrane__ipsc_confocal__fnet3d_paper__a549_mantis_caax_zikv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet3d_paper/checkpoints/epoch=181-step=157612.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_MEMB_ON_A549_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__hek_mantis_kras_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__hek_mantis_kras_a549xy.yml new file mode 100644 index 000000000..b86368474 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__hek_mantis_kras_a549xy.yml @@ -0,0 +1,48 @@ +# fnet3d_paper predict: membrane trained on ipsc_confocal, +# predicting against the HEK293T third-cell-type probe (KRAS, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# membrane/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'fnet3d_paper' (config dir 'fnet3d_paper'). +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_kras_a549xy.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: hek_mantis_kras_a549xy + model_name: fnet3d_paper + experiment_id: membrane__ipsc_confocal__fnet3d_paper__hek_mantis_kras_a549xy + dataset_ref: + target: kras +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet3d_paper/checkpoints/epoch=181-step=157612.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/hek__a549xy/prediction.zarr +launcher: + job_name: FNET3D_PRED_MEMBRANE_IPSCTR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml index 131b53480..e452d7985 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml @@ -18,7 +18,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fnet3d_paper/checkpoints/epoch=181-step=157612.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet3d_paper/checkpoints/epoch=181-step=157612.ckpt data: init_args: @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fnet3d_paper.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/ipsc/prediction.zarr launcher: job_name: FNet3DPaper_PRED_MEMB - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..a55b729c1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: fnet3d_paper + experiment_id: membrane__ipsc_confocal__fnet3d_paper__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet3d_paper/checkpoints/epoch=181-step=157612.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/ipsc/ipsc/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_MEMB_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/fnet3d_paper/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/train.yml index 196645011..c2b4958d8 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/ipsc_confocal/train.yml @@ -50,7 +50,7 @@ trainer: logger: init_args: name: FNet3D_iPSC_MEMB_paper - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fnet3d_paper + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet3d_paper callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -58,14 +58,16 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fnet3d_paper/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet3d_paper/checkpoints launcher: job_name: FNet3DPaper_MEMB - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/memb/fnet3d_paper + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/fnet3d_paper # cell.zarr-backed preload (same plate as nucleus) puts MaxVMSize over # the shared 256G cap; bump to match nucleus. sbatch: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index 6a7323266..519036b2c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -26,7 +26,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fnet3d_paper/checkpoints/epoch=116-step=180882.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fnet3d_paper/checkpoints/epoch=116-step=180882.ckpt data: init_args: @@ -43,8 +43,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_jointtrained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/a549__denv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_MEMB_JOINTTR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index 0f08c06fc..30544ed23 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -26,7 +26,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fnet3d_paper/checkpoints/epoch=116-step=180882.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fnet3d_paper/checkpoints/epoch=116-step=180882.ckpt data: init_args: @@ -43,8 +43,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_jointtrained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/a549__mock/prediction.zarr launcher: job_name: FNet3DPaper_PRED_MEMB_JOINTTR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index 2c10aa869..395bc177e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -26,7 +26,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fnet3d_paper/checkpoints/epoch=116-step=180882.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fnet3d_paper/checkpoints/epoch=116-step=180882.ckpt data: init_args: @@ -43,8 +43,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_fnet3d_paper_jointtrained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/a549__zikv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_MEMB_JOINTTR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_kras_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_kras_a549xy.yml new file mode 100644 index 000000000..b1e9e952f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_kras_a549xy.yml @@ -0,0 +1,48 @@ +# fnet3d_paper predict: membrane trained on joint_ipsc_confocal_a549_mantis, +# predicting against the HEK293T third-cell-type probe (KRAS, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'fnet3d_paper' (config dir 'fnet3d_paper'). +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_kras_a549xy.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: hek_mantis_kras_a549xy + model_name: fnet3d_paper + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__fnet3d_paper__hek_mantis_kras_a549xy + dataset_ref: + target: kras +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fnet3d_paper/checkpoints/epoch=116-step=180882.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/hek__a549xy/prediction.zarr +launcher: + job_name: FNET3D_PRED_MEMBRANE_JOINTTR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index 90ebcd991..0cf592157 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -21,7 +21,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fnet3d_paper/checkpoints/epoch=116-step=180882.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fnet3d_paper/checkpoints/epoch=116-step=180882.ckpt data: init_args: @@ -38,8 +38,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_fnet3d_paper_jointtrained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/ipsc/prediction.zarr launcher: job_name: FNet3DPaper_PRED_MEMB_JOINTTR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/fnet3d_paper/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/train.yml index e3426b997..4f486ad27 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/fnet3d_paper/joint_ipsc_confocal_a549_mantis/train.yml @@ -34,7 +34,7 @@ trainer: logger: init_args: name: FNet3D_JOINT_MEMB_paper - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fnet3d_paper + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fnet3d_paper callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -42,10 +42,12 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fnet3d_paper/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fnet3d_paper/checkpoints _hcs_init_args: &hcs_init_args source_channel: Phase3D @@ -115,7 +117,7 @@ data: launcher: job_name: FNet3DPaper_JOINT_MEMB - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/fnet3d_paper + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/fnet3d_paper # 512G to match the shared headroom convention across the fnet3d # leaves on a549/joint workloads. mmap_preload after the BasicIndexer # fix peaks at ~185 GB for joint cell.zarr + CAAX_all; 512G gives diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..40fb5f054 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,72 @@ +# pix2pix2d predict: membrane trained on a549_mantis, tested on A549 mantis denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/membrane.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_denv + model_name: pix2pix2d_unetvit + experiment_id: membrane__a549_mantis__pix2pix2d_unetvit__a549_mantis_caax_denv + # A549 keys this organelle by gene; override the iPSC-side target + # from the target fragment so the resolver finds it on the A549 set. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix2d_unetvit/checkpoints/epoch=38-step=11700-loss=0.590.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/a549__denv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_A549_MEMB_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..494793156 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,72 @@ +# pix2pix2d predict: membrane trained on a549_mantis, tested on A549 mantis mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/membrane.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_mock + model_name: pix2pix2d_unetvit + experiment_id: membrane__a549_mantis__pix2pix2d_unetvit__a549_mantis_caax_mock + # A549 keys this organelle by gene; override the iPSC-side target + # from the target fragment so the resolver finds it on the A549 set. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix2d_unetvit/checkpoints/epoch=38-step=11700-loss=0.590.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/a549__mock/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_A549_MEMB_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..8fd7b1c22 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,72 @@ +# pix2pix2d predict: membrane trained on a549_mantis, tested on A549 mantis zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/membrane.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_zikv + model_name: pix2pix2d_unetvit + experiment_id: membrane__a549_mantis__pix2pix2d_unetvit__a549_mantis_caax_zikv + # A549 keys this organelle by gene; override the iPSC-side target + # from the target fragment so the resolver finds it on the A549 set. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix2d_unetvit/checkpoints/epoch=38-step=11700-loss=0.590.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/a549__zikv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_A549_MEMB_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..343a5d18f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: membrane trained on a549_mantis, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/membrane.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit + experiment_id: membrane__a549_mantis__pix2pix2d_unetvit__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix2d_unetvit/checkpoints/epoch=38-step=11700-loss=0.590.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/ipsc/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_A549_MEMB_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/train.yml new file mode 100644 index 000000000..aef1c7502 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/a549_mantis/train.yml @@ -0,0 +1,102 @@ +# pix2pix2d_unetvit (UNetViT generator + multi-scale PatchGAN, run +# Z-preserving at Z=1) fit on membrane (Membrane channel) — A549 mantis-lightsheet pooled (mock + DENV + ZIKV), +# in-focus 2D track. Mirror of the 3D +# membrane/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml leaf, +# flattened onto the offline 5-plane in-focus slab store (z_window_size=1 +# emits one in-focus window per plane). +# +# ⚠ Mirrors train_4gpu_modernized.yml, NOT the stale sibling train.yml. The +# published pix2pix3d rows came from the modernized "Run D" recipe — the +# checkpoints carry loss_type='nonsat', lr 2e-4/2e-4, r1_gamma=10, +# ema_kimg=10, lecam_gamma=0.3, lambda_l1=10 and 201 generator_ema.* tensors +# — while train.yml still composes the LSGAN baseline overlay. All of Run D is +# baked into model_overlays/pix2pix2d_unetvit_fit.yml, so unlike the 3D leaves +# this file repeats none of it. +# +# The 3D leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus store. +# The 2D track reads the `_focus.zarr` slab instead, so the resolver is +# disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field co-declared +# with a full dataset_ref. +# +# The train_set fragment supplies data.class_path (HCSDataModule) plus +# split_ratio / mmap_preload / scratch_dir. targets/membrane.yml supplies the +# NormalizeSampled(fov_statistics) normalization the pix2pix leaves use +# (mean/std on Phase3D, median/iqr on the target); only its RandWeightedCropd +# is list-replaced below, flattened [13,624,624] -> [1,624,624]. + +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + gene: Membrane + target: membrane + target_id: membrane + train_set: a549_mantis + model_name: pix2pix2d_unetvit + experiment_id: membrane__a549_mantis__pix2pix2d_unetvit + # Disable the manifest resolver: the 2D track reads the offline focus store, + # not the manifest-registered non-focus store. + dataset_ref: null + +data: + init_args: + # pooled A549 in-focus slab store (Membrane channel) — resolver disabled above. + source_channel: Phase3D + target_channel: Membrane + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + # Flatten the target fragment's [13, 624, 624] weighted crop to Z=1. + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Membrane] + w_key: Membrane + spatial_size: [1, 624, 624] + num_samples: 2 + +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_A549_MEMB + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix2d_unetvit + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + # monitor loss/validate_ema, matching the 3D Run-D leaves: ema_kimg is set, + # so the EMA generator is the one the recipe selects on and the one predict + # reports. Monitoring the raw loss/validate would pin a different epoch. + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix2d_unetvit/checkpoints + +launcher: + job_name: pix2pix2d_unetvit_A549_MEMB + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix2d_unetvit + sbatch: + # Narrow OFF the hardware_4gpu h100|h200 default, the opposite of the 3D + # leaf. 3D needed h200 because the GAN OOMs 80 GB at Z=8; measured at Z=1 + # on an A40 (44.7 GiB) peak is 13.3 GiB/rank at batch_size 4, so the 48 GB + # cards have 3x headroom and reserving Hopper for this would be queue + # squatting. The profile documents this opt-out explicitly. + constraint: "a40|a6000|l40s|h100|h200" + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D store + # (~1/4 the Z), so the profile's 512G mmap_preload headroom is inherited 3D + # scale. Set in the LEAF BODY because launcher_profiles compose after model + # overlays and would otherwise win. + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..06dbe712e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,72 @@ +# pix2pix2d predict: membrane trained on ipsc_confocal, tested on A549 mantis denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/membrane.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_denv + model_name: pix2pix2d_unetvit + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit__a549_mantis_caax_denv + # A549 keys this organelle by gene; override the iPSC-side target + # from the target fragment so the resolver finds it on the A549 set. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit/checkpoints/epoch=37-step=19000-loss=0.451.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_MEMB_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..463b175ed --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,72 @@ +# pix2pix2d predict: membrane trained on ipsc_confocal, tested on A549 mantis mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/membrane.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_mock + model_name: pix2pix2d_unetvit + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit__a549_mantis_caax_mock + # A549 keys this organelle by gene; override the iPSC-side target + # from the target fragment so the resolver finds it on the A549 set. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit/checkpoints/epoch=37-step=19000-loss=0.451.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_MEMB_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..6c5bb0838 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,72 @@ +# pix2pix2d predict: membrane trained on ipsc_confocal, tested on A549 mantis zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/membrane.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_zikv + model_name: pix2pix2d_unetvit + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit__a549_mantis_caax_zikv + # A549 keys this organelle by gene; override the iPSC-side target + # from the target fragment so the resolver finds it on the A549 set. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit/checkpoints/epoch=37-step=19000-loss=0.451.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_MEMB_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..8b7c9273c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: membrane trained on ipsc_confocal, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/membrane.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit/checkpoints/epoch=37-step=19000-loss=0.451.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/ipsc/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_MEMB_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/train.yml new file mode 100644 index 000000000..4759d99ac --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/ipsc_confocal/train.yml @@ -0,0 +1,102 @@ +# pix2pix2d_unetvit (UNetViT generator + multi-scale PatchGAN, run +# Z-preserving at Z=1) fit on membrane (Membrane channel) — AICS iPSC confocal, +# in-focus 2D track. Mirror of the 3D +# membrane/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml leaf, +# flattened onto the offline 5-plane in-focus slab store (z_window_size=1 +# emits one in-focus window per plane). +# +# ⚠ Mirrors train_4gpu_modernized.yml, NOT the stale sibling train.yml. The +# published pix2pix3d rows came from the modernized "Run D" recipe — the +# checkpoints carry loss_type='nonsat', lr 2e-4/2e-4, r1_gamma=10, +# ema_kimg=10, lecam_gamma=0.3, lambda_l1=10 and 201 generator_ema.* tensors +# — while train.yml still composes the LSGAN baseline overlay. All of Run D is +# baked into model_overlays/pix2pix2d_unetvit_fit.yml, so unlike the 3D leaves +# this file repeats none of it. +# +# The 3D leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus store. +# The 2D track reads the `_focus.zarr` slab instead, so the resolver is +# disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field co-declared +# with a full dataset_ref. +# +# The train_set fragment supplies data.class_path (HCSDataModule) plus +# split_ratio / mmap_preload / scratch_dir. targets/membrane.yml supplies the +# NormalizeSampled(fov_statistics) normalization the pix2pix leaves use +# (mean/std on Phase3D, median/iqr on the target); only its RandWeightedCropd +# is list-replaced below, flattened [13,624,624] -> [1,624,624]. + +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + gene: Membrane + target: membrane + target_id: membrane + train_set: ipsc_confocal + model_name: pix2pix2d_unetvit + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit + # Disable the manifest resolver: the 2D track reads the offline focus store, + # not the manifest-registered non-focus store. + dataset_ref: null + +data: + init_args: + # aics-hipsc in-focus slab store (Membrane channel) — resolver disabled above. + source_channel: Phase3D + target_channel: Membrane + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + # Flatten the target fragment's [13, 624, 624] weighted crop to Z=1. + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Membrane] + w_key: Membrane + spatial_size: [1, 624, 624] + num_samples: 2 + +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_iPSC_MEMB + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + # monitor loss/validate_ema, matching the 3D Run-D leaves: ema_kimg is set, + # so the EMA generator is the one the recipe selects on and the one predict + # reports. Monitoring the raw loss/validate would pin a different epoch. + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit/checkpoints + +launcher: + job_name: pix2pix2d_unetvit_iPSC_MEMB + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit + sbatch: + # Narrow OFF the hardware_4gpu h100|h200 default, the opposite of the 3D + # leaf. 3D needed h200 because the GAN OOMs 80 GB at Z=8; measured at Z=1 + # on an A40 (44.7 GiB) peak is 13.3 GiB/rank at batch_size 4, so the 48 GB + # cards have 3x headroom and reserving Hopper for this would be queue + # squatting. The profile documents this opt-out explicitly. + constraint: "a40|a6000|l40s|h100|h200" + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D store + # (~1/4 the Z), so the profile's 512G mmap_preload headroom is inherited 3D + # scale. Set in the LEAF BODY because launcher_profiles compose after model + # overlays and would otherwise win. + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..ff19618d6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,72 @@ +# pix2pix2d predict: membrane trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/membrane.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_denv + model_name: pix2pix2d_unetvit + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit__a549_mantis_caax_denv + # A549 keys this organelle by gene; override the iPSC-side target + # from the target fragment so the resolver finds it on the A549 set. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix2d_unetvit/checkpoints/epoch=24-step=20000-loss=0.497.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/a549__denv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_JOINT_MEMB_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..fca5ba357 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,72 @@ +# pix2pix2d predict: membrane trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/membrane.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_mock + model_name: pix2pix2d_unetvit + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit__a549_mantis_caax_mock + # A549 keys this organelle by gene; override the iPSC-side target + # from the target fragment so the resolver finds it on the A549 set. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix2d_unetvit/checkpoints/epoch=24-step=20000-loss=0.497.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/a549__mock/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_JOINT_MEMB_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..e092f39b0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,72 @@ +# pix2pix2d predict: membrane trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/membrane.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_zikv + model_name: pix2pix2d_unetvit + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit__a549_mantis_caax_zikv + # A549 keys this organelle by gene; override the iPSC-side target + # from the target fragment so the resolver finds it on the A549 set. + dataset_ref: + target: caax + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix2d_unetvit/checkpoints/epoch=24-step=20000-loss=0.497.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/a549__zikv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_JOINT_MEMB_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..6c13dbb05 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: membrane trained on joint_ipsc_confocal_a549_mantis, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/membrane.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/membrane.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix2d_unetvit/checkpoints/epoch=24-step=20000-loss=0.497.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/ipsc/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_JOINT_MEMB_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..4193ac097 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,170 @@ +# pix2pix2d_unetvit (UNetViT generator + multi-scale PatchGAN, run +# Z-preserving at Z=1) fit on membrane (Membrane channel) — joint ipsc_confocal + a549_mantis pooled, +# in-focus 2D track. Mirror of the 3D +# membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml leaf, +# flattened onto the offline 5-plane in-focus slab store (z_window_size=1 +# emits one in-focus window per plane). +# +# ⚠ Mirrors train_4gpu_modernized.yml, NOT the stale sibling train.yml. The +# published pix2pix3d rows came from the modernized "Run D" recipe — the +# checkpoints carry loss_type='nonsat', lr 2e-4/2e-4, r1_gamma=10, +# ema_kimg=10, lecam_gamma=0.3, lambda_l1=10 and 201 generator_ema.* tensors +# — while train.yml still composes the LSGAN baseline overlay. All of Run D is +# baked into model_overlays/pix2pix2d_unetvit_fit.yml, so unlike the 3D leaves +# this file repeats none of it. +# +# BatchedConcatDataModule + two explicit HCSDataModule children; only +# model_overlays/pix2pix2d_unetvit_fit.yml is composed (the data block is +# authored inline here, not via data_overlays). +# +# Normalization is NormalizeSampled (fov_statistics), matching the single-set +# pix2pix2d leaves — divergent from the celldiff joint, which uses +# MinMaxSampled. Per-organelle prior is to keep joint and single-set +# normalizations identical so ablations are apples-to-apples. +# +# batch_size 2 here, NOT the single-set 4: BatchedConcatDataModule's +# train_dataloader uses batch_size as-is, while HCSDataModule divides by +# RandWeightedCropd num_samples. 2 indices * 2 num_samples = 4 GPU samples per +# rank, x 4 DDP ranks = the same 16 samples/step as the 3D arm. +base: + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: membrane + gene: Membrane + target: membrane + target_id: membrane + train_set: joint_ipsc_confocal_a549_mantis + model_name: pix2pix2d_unetvit + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit + +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_JOINT_MEMB + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix2d_unetvit + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + # monitor loss/validate_ema, matching the 3D Run-D leaves: ema_kimg is set, + # so the EMA generator is the one the recipe selects on and the one predict + # reports. Monitoring the raw loss/validate would pin a different epoch. + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix2d_unetvit/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Membrane + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: [512, 512] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Membrane] + level: fov_statistics + subtrahend: median + divisor: iqr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Membrane] + w_key: Membrane + spatial_size: [1, 624, 624] + num_samples: 2 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [0, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[1, 1], [0.5, 1.5], [0.5, 1.5]] + safe_crop_size: [1, 512, 512] + safe_crop_coverage: 0.9 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0, 0] + val_gpu_augmentations: + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc in-focus slab store (Membrane channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + # a549_mantis — pooled A549 in-focus slab store (Membrane channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + +launcher: + job_name: pix2pix2d_unetvit_JOINT_MEMB + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix2d_unetvit + sbatch: + # Narrow OFF the hardware_4gpu h100|h200 default, the opposite of the 3D + # leaf. 3D needed h200 because the GAN OOMs 80 GB at Z=8; measured at Z=1 + # on an A40 (44.7 GiB) peak is 13.3 GiB/rank at batch_size 4, so the 48 GB + # cards have 3x headroom and reserving Hopper for this would be queue + # squatting. The profile documents this opt-out explicitly. + constraint: "a40|a6000|l40s|h100|h200" + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D store + # (~1/4 the Z), so the profile's 512G mmap_preload headroom is inherited 3D + # scale. Set in the LEAF BODY because launcher_profiles compose after model + # overlays and would otherwise win. + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..b19d67174 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,45 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_denv + model_name: pix2pix2d_unetvit_seed1 + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit_seed1__a549_mantis_caax_denv + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_seed1/ipsc/a549__denv/prediction.zarr +launcher: + job_name: pix2pix2D_PRED_MEMB_ON_A549_DENV_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_seed1/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..4c6890dfc --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,45 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_mock + model_name: pix2pix2d_unetvit_seed1 + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit_seed1__a549_mantis_caax_mock + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_seed1/ipsc/a549__mock/prediction.zarr +launcher: + job_name: pix2pix2D_PRED_MEMB_ON_A549_MOCK_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_seed1/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..19c0ee550 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,45 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_zikv + model_name: pix2pix2d_unetvit_seed1 + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit_seed1__a549_mantis_caax_zikv + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_seed1/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: pix2pix2D_PRED_MEMB_ON_A549_ZIKV_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_seed1/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..355cc430e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,43 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf membrane/pix2pix2d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit_seed1 + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit_seed1__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_seed1/ipsc/ipsc/prediction.zarr +launcher: + job_name: pix2pix2D_PRED_MEMB_ON_IPSC_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_seed1/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/train.yml new file mode 100644 index 000000000..f8b63eabe --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_seed1/ipsc_confocal/train.yml @@ -0,0 +1,65 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (fit) of the baseline leaf membrane/pix2pix2d_unetvit/ipsc_confocal/train.yml. +# Recipe delta vs that leaf: seed_everything: 1. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/train_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + gene: Membrane + target: membrane + target_id: membrane + train_set: ipsc_confocal + model_name: pix2pix2d_unetvit_seed1 + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit_seed1 + dataset_ref: null +data: + init_args: + source_channel: Phase3D + target_channel: Membrane + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Membrane + w_key: Membrane + spatial_size: + - 1 + - 624 + - 624 + num_samples: 2 +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_iPSC_MEMB_seed1 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_seed1 + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: epoch={epoch}-step={step}-loss={loss/validate_ema:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_seed1/checkpoints +launcher: + job_name: pix2pix2d_unetvit_iPSC_MEMB_seed1 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_seed1 + sbatch: + constraint: a40|a6000|l40s|h100|h200 + mem: 128G +seed_everything: 1 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..e729c7ac8 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch` arm (predict) of membrane/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_denv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: membrane__a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_caax_denv + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix2d_unetvit_wmatch/checkpoints/epoch=39-step=12000-loss=0.572.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/a549/a549__denv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_A549_MEMB_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..cea34a20f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch` arm (predict) of membrane/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_mock + model_name: pix2pix2d_unetvit_wmatch + experiment_id: membrane__a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_caax_mock + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix2d_unetvit_wmatch/checkpoints/epoch=39-step=12000-loss=0.572.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/a549/a549__mock/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_A549_MEMB_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..cc44ce9f2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch` arm (predict) of membrane/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: a549_mantis_caax_zikv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: membrane__a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_caax_zikv + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix2d_unetvit_wmatch/checkpoints/epoch=39-step=12000-loss=0.572.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/a549/a549__zikv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_A549_MEMB_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..528ee9619 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of membrane/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch + experiment_id: membrane__a549_mantis__pix2pix2d_unetvit_wmatch__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix2d_unetvit_wmatch/checkpoints/epoch=39-step=12000-loss=0.572.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/a549/ipsc/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_A549_MEMB_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/train.yml new file mode 100644 index 000000000..df7754c6a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/a549_mantis/train.yml @@ -0,0 +1,69 @@ +# pix2pix2d `wmatch` arm (fit) of membrane/pix2pix2d_unetvit/a549_mantis/train.yml. +# Recipe delta: warmup_steps 8500 -> 1181. Run-D's 8500-batch warmup is +# 19.7 % of the matching 3D fit (43200 batches); this 2D fit runs 6000, so +# round(8500 * 6000 / 43200) keeps the same schedule shape. The baseline's absolute 8500 +# left 5 of 12 2D fits still warming up at their last step (wandb lr-AdamW, 2026-10-22). +# Everything else, and the rationale for it, is the baseline leaf's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_fit_leaves.py. +base: +- ../../../_internal/shared/model/train_sets/a549_mantis.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + gene: Membrane + target: membrane + target_id: membrane + train_set: a549_mantis + model_name: pix2pix2d_unetvit_wmatch + experiment_id: membrane__a549_mantis__pix2pix2d_unetvit_wmatch + dataset_ref: null +data: + init_args: + source_channel: Phase3D + target_channel: Membrane + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Membrane + w_key: Membrane + spatial_size: + - 1 + - 624 + - 624 + num_samples: 2 +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_wmatch_A549_MEMB + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix2d_unetvit_wmatch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: epoch={epoch}-step={step}-loss={loss/validate_ema:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix2d_unetvit_wmatch/checkpoints +launcher: + job_name: pix2pix2d_unetvit_wmatch_A549_MEMB + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix2d_unetvit_wmatch + sbatch: + constraint: a40|a6000|l40s|h100|h200 + mem: 128G +model: + init_args: + warmup_steps: 1181 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..646cc5fc2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch` arm (predict) of membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_denv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit_wmatch__a549_mantis_caax_denv + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_wmatch/checkpoints/epoch=29-step=15000-loss=0.449.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/ipsc/a549__denv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_MEMB_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..ccbffbe85 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch` arm (predict) of membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_mock + model_name: pix2pix2d_unetvit_wmatch + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit_wmatch__a549_mantis_caax_mock + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_wmatch/checkpoints/epoch=29-step=15000-loss=0.449.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/ipsc/a549__mock/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_MEMB_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..b1eb4a5ad --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch` arm (predict) of membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_zikv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit_wmatch__a549_mantis_caax_zikv + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_wmatch/checkpoints/epoch=29-step=15000-loss=0.449.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_MEMB_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..cf5d9d7ba --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of membrane/pix2pix2d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit_wmatch__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_wmatch/checkpoints/epoch=29-step=15000-loss=0.449.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/ipsc/ipsc/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_MEMB_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/train.yml new file mode 100644 index 000000000..f488bba1f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/ipsc_confocal/train.yml @@ -0,0 +1,69 @@ +# pix2pix2d `wmatch` arm (fit) of membrane/pix2pix2d_unetvit/ipsc_confocal/train.yml. +# Recipe delta: warmup_steps 8500 -> 1328. Run-D's 8500-batch warmup is +# 13.3 % of the matching 3D fit (64000 batches); this 2D fit runs 10000, so +# round(8500 * 10000 / 64000) keeps the same schedule shape. The baseline's absolute 8500 +# left 5 of 12 2D fits still warming up at their last step (wandb lr-AdamW, 2026-10-22). +# Everything else, and the rationale for it, is the baseline leaf's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_fit_leaves.py. +base: +- ../../../_internal/shared/model/train_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + gene: Membrane + target: membrane + target_id: membrane + train_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit_wmatch + dataset_ref: null +data: + init_args: + source_channel: Phase3D + target_channel: Membrane + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Membrane + w_key: Membrane + spatial_size: + - 1 + - 624 + - 624 + num_samples: 2 +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_wmatch_iPSC_MEMB + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_wmatch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: epoch={epoch}-step={step}-loss={loss/validate_ema:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_wmatch/checkpoints +launcher: + job_name: pix2pix2d_unetvit_wmatch_iPSC_MEMB + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_wmatch + sbatch: + constraint: a40|a6000|l40s|h100|h200 + mem: 128G +model: + init_args: + warmup_steps: 1328 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..96d468ec5 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch` arm (predict) of membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_denv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_caax_denv + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix2d_unetvit_wmatch/checkpoints/epoch=24-step=20000-loss=0.497.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/joint/a549__denv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_JOINT_MEMB_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..4eb2acaf0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch` arm (predict) of membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_mock + model_name: pix2pix2d_unetvit_wmatch + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_caax_mock + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix2d_unetvit_wmatch/checkpoints/epoch=24-step=20000-loss=0.497.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/joint/a549__mock/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_JOINT_MEMB_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..dd685e52c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch` arm (predict) of membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_caax_zikv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_caax_zikv + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix2d_unetvit_wmatch/checkpoints/epoch=24-step=20000-loss=0.497.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/joint/a549__zikv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_JOINT_MEMB_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..a25b676b1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix2d_unetvit_wmatch/checkpoints/epoch=24-step=20000-loss=0.497.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/joint/ipsc/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_JOINT_MEMB_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..33bbe5053 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,207 @@ +# pix2pix2d `wmatch` arm (fit) of membrane/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml. +# Recipe delta: warmup_steps 8500 -> 1269. Run-D's 8500-batch warmup is +# 7.9 % of the matching 3D fit (107200 batches); this 2D fit runs 16000, so +# round(8500 * 16000 / 107200) keeps the same schedule shape. The baseline's absolute 8500 +# left 5 of 12 2D fits still warming up at their last step (wandb lr-AdamW, 2026-10-22). +# Everything else, and the rationale for it, is the baseline leaf's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_fit_leaves.py. +base: +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + gene: Membrane + target: membrane + target_id: membrane + train_set: joint_ipsc_confocal_a549_mantis + model_name: pix2pix2d_unetvit_wmatch + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_wmatch_JOINT_MEMB + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix2d_unetvit_wmatch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: epoch={epoch}-step={step}-loss={loss/validate_ema:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix2d_unetvit_wmatch/checkpoints +_hcs_init_args: + source_channel: Phase3D + target_channel: Membrane + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: &id001 + - 512 + - 512 + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: &id002 + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Membrane + level: fov_statistics + subtrahend: median + divisor: iqr + augmentations: &id003 + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Membrane + w_key: Membrane + spatial_size: + - 1 + - 624 + - 624 + num_samples: 2 + gpu_augmentations: &id004 + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: + - source + - target + prob: 0.8 + rotate_range: + - 0 + - 0 + - 0 + shear_range: + - 0.0 + - 0.05 + - 0.05 + scale_range: + - - 1 + - 1 + - - 0.5 + - 1.5 + - - 0.5 + - 1.5 + safe_crop_size: + - 1 + - 512 + - 512 + safe_crop_coverage: 0.9 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: + - source + - target + roi_size: + - 1 + - 512 + - 512 + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: + - source + prob: 0.5 + gamma: + - 0.8 + - 1.2 + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: + - source + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: + - source + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: + - source + prob: 0.5 + sigma_x: + - 0.25 + - 0.75 + sigma_y: + - 0.25 + - 0.75 + sigma_z: + - 0 + - 0 + val_gpu_augmentations: &id005 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: + - source + - target + roi_size: + - 1 + - 512 + - 512 +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + - class_path: viscy_data.hcs.HCSDataModule + init_args: + source_channel: Phase3D + target_channel: Membrane + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: *id001 + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: *id002 + augmentations: *id003 + gpu_augmentations: *id004 + val_gpu_augmentations: *id005 + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + - class_path: viscy_data.hcs.HCSDataModule + init_args: + source_channel: Phase3D + target_channel: Membrane + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: *id001 + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: *id002 + augmentations: *id003 + gpu_augmentations: *id004 + val_gpu_augmentations: *id005 + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_JOINT_MEMB + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix2d_unetvit_wmatch + sbatch: + constraint: a40|a6000|l40s|h100|h200 + mem: 128G +model: + init_args: + warmup_steps: 1269 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..01d7f46bc --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch_seed1` arm (predict) of membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_denv + model_name: pix2pix2d_unetvit_wmatch_seed1 + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit_wmatch_seed1__a549_mantis_caax_denv + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_wmatch_seed1/checkpoints/epoch=24-step=12500-loss=0.469.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__denv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_seed1_PRED_MEMB_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..85a7eb6e7 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch_seed1` arm (predict) of membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_mock + model_name: pix2pix2d_unetvit_wmatch_seed1 + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit_wmatch_seed1__a549_mantis_caax_mock + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_wmatch_seed1/checkpoints/epoch=24-step=12500-loss=0.469.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__mock/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_seed1_PRED_MEMB_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..34f05e99a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch_seed1` arm (predict) of membrane/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_zikv + model_name: pix2pix2d_unetvit_wmatch_seed1 + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit_wmatch_seed1__a549_mantis_caax_zikv + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_wmatch_seed1/checkpoints/epoch=24-step=12500-loss=0.469.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_seed1_PRED_MEMB_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..5c411cfb1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch_seed1` arm (predict) of membrane/pix2pix2d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch_seed1 + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit_wmatch_seed1__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_wmatch_seed1/checkpoints/epoch=24-step=12500-loss=0.469.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/membrane/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/ipsc/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_seed1_PRED_MEMB_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/train.yml new file mode 100644 index 000000000..2d29052fd --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/train.yml @@ -0,0 +1,71 @@ +# pix2pix2d `wmatch_seed1` arm (fit) of membrane/pix2pix2d_unetvit/ipsc_confocal/train.yml. +# Recipe delta: warmup_steps 8500 -> 1328. Run-D's 8500-batch warmup is +# 13.3 % of the matching 3D fit (64000 batches); this 2D fit runs 10000, so +# round(8500 * 10000 / 64000) keeps the same schedule shape. The baseline's absolute 8500 +# left 5 of 12 2D fits still warming up at their last step (wandb lr-AdamW, 2026-10-22). +# Plus seed_everything: 1 (second draw of the arm). +# Everything else, and the rationale for it, is the baseline leaf's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_fit_leaves.py. +base: +- ../../../_internal/shared/model/train_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + gene: Membrane + target: membrane + target_id: membrane + train_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch_seed1 + experiment_id: membrane__ipsc_confocal__pix2pix2d_unetvit_wmatch_seed1 + dataset_ref: null +data: + init_args: + source_channel: Phase3D + target_channel: Membrane + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Membrane + w_key: Membrane + spatial_size: + - 1 + - 624 + - 624 + num_samples: 2 +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_wmatch_seed1_iPSC_MEMB + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_wmatch_seed1 + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: epoch={epoch}-step={step}-loss={loss/validate_ema:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_wmatch_seed1/checkpoints +launcher: + job_name: pix2pix2d_unetvit_wmatch_seed1_iPSC_MEMB + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix2d_unetvit_wmatch_seed1 + sbatch: + constraint: a40|a6000|l40s|h100|h200 + mem: 128G +model: + init_args: + warmup_steps: 1328 +seed_everything: 1 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_denv.yml index 61ffe0e36..3df27ef06 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_denv.yml @@ -23,7 +23,7 @@ model: init_args: # Best loss/validate_ema checkpoint of the modernized Run-D 40ep A549 # membrane run (job 33674784, best at epoch 37, validate_ema=0.3792). - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/memb/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=37-step=82080.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix3d_unetvit/checkpoints/epoch=37-step=82080.ckpt data: init_args: @@ -42,8 +42,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit_a549trained__caax_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__denv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_A549TR_PRED_MEMB_caax_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_mock.yml index de407063c..026c0ee91 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_mock.yml @@ -23,7 +23,7 @@ model: init_args: # Best loss/validate_ema checkpoint of the modernized Run-D 40ep A549 # membrane run (job 33674784, best at epoch 37, validate_ema=0.3792). - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/memb/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=37-step=82080.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix3d_unetvit/checkpoints/epoch=37-step=82080.ckpt data: init_args: @@ -42,8 +42,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit_a549trained__caax_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__mock/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_A549TR_PRED_MEMB_caax_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml index 938039915..b1b8aa575 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml @@ -23,7 +23,7 @@ model: init_args: # Best loss/validate_ema checkpoint of the modernized Run-D 40ep A549 # membrane run (job 33674784, best at epoch 37, validate_ema=0.3792). - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/memb/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=37-step=82080.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix3d_unetvit/checkpoints/epoch=37-step=82080.ckpt data: init_args: @@ -42,8 +42,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit_a549trained__caax_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__zikv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_A549TR_PRED_MEMB_caax_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__hek_mantis_kras_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__hek_mantis_kras_a549xy.yml new file mode 100644 index 000000000..db63869f9 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__hek_mantis_kras_a549xy.yml @@ -0,0 +1,49 @@ +# pix2pix3d_unetvit predict: membrane trained on a549_mantis, +# predicting against the HEK293T third-cell-type probe (KRAS, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# membrane/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'pix2pix3d_unetvit' (config dir 'pix2pix3d_unetvit'). +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_kras_a549xy.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix3d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: a549_mantis + predict_set: hek_mantis_kras_a549xy + model_name: pix2pix3d_unetvit + experiment_id: membrane__a549_mantis__pix2pix3d_unetvit__hek_mantis_kras_a549xy + dataset_ref: + target: kras +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix3d_unetvit/checkpoints/epoch=37-step=82080.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/hek__a549xy/prediction.zarr + z_reduction: center +launcher: + job_name: PIX2PIX3D_PRED_MEMBRANE_A549TR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__ipsc_confocal.yml index 00af70de5..645e60648 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/predict__ipsc_confocal.yml @@ -21,7 +21,7 @@ model: # membrane run (job 33674784 / wandb 20260604-221028, best at epoch 37, # validate_ema=0.3792). iPSC keys membrane as `membrane`, so no # dataset_ref override is needed here (unlike the A549 test leaves). - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/memb/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=37-step=82080.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix3d_unetvit/checkpoints/epoch=37-step=82080.ckpt data: init_args: @@ -40,8 +40,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_pix2pix3d_unetvit_a549trained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/ipsc/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_A549TR_PRED_MEMB_ON_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/train.yml index e1641459f..033b38b98 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/train.yml @@ -27,6 +27,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml index 00355127a..aa7b02387 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml @@ -29,7 +29,7 @@ trainer: logger: init_args: name: pix2pix3d_unetvit_A549_MEMB_4gpu_modernized_lambdaL1_10_lecam_40ep - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/memb/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix3d_unetvit callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -37,10 +37,12 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/memb/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix3d_unetvit/checkpoints data: init_args: @@ -50,7 +52,7 @@ data: launcher: job_name: pix2pix3d_unetvit_A549_MEMB_4gpu_modernized_lambdaL1_10_lecam_40ep - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/memb/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/membrane/pix2pix3d_unetvit # pix2pix3d GAN (UNetViT3D G + multiscale-patch D, large 3D crops) OOMs on # 80 GB h100; needs h200 (141 GB). Narrow the hardware_4gpu h100|h200 default. sbatch: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index e5139dea8..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: membrane (Membrane) predicted by pix2pix3d_unetvit on a549-mantis-caax-denv. -defaults: - - override /target: membrane - - override /predict_set: a549_mantis_caax_denv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit__caax_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_memb_pix2pix3d_unetvit__caax_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index f93b7f83c..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: membrane (Membrane) predicted by pix2pix3d_unetvit on a549-mantis-caax-mock. -defaults: - - override /target: membrane - - override /predict_set: a549_mantis_caax_mock - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit__caax_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_memb_pix2pix3d_unetvit__caax_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index 8c4a62a9a..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: membrane (Membrane) predicted by pix2pix3d_unetvit on a549-mantis-caax-zikv. -defaults: - - override /target: membrane - - override /predict_set: a549_mantis_caax_zikv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit__caax_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_memb_pix2pix3d_unetvit__caax_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 100644 index 3d4a89595..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: membrane (Membrane) predicted by pix2pix3d_unetvit on iPSC confocal. -defaults: - - override /target: membrane - - override /predict_set: ipsc_confocal - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_pix2pix3d_unetvit.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/eval_memb_pix2pix3d_unetvit diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml index dd2a12967..f8ed629e7 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml @@ -19,7 +19,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=25-step=83200.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix3d_unetvit/checkpoints/epoch=25-step=83200.ckpt data: init_args: @@ -38,8 +38,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit__caax_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__denv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_PRED_MEMB_ON_A549_caax_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml index 540191395..862137a3d 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml @@ -19,7 +19,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=25-step=83200.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix3d_unetvit/checkpoints/epoch=25-step=83200.ckpt data: init_args: @@ -38,8 +38,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit__caax_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__mock/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_PRED_MEMB_ON_A549_caax_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml index cbacbed31..b29aa4643 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -19,7 +19,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=25-step=83200.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix3d_unetvit/checkpoints/epoch=25-step=83200.ckpt data: init_args: @@ -38,8 +38,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_pix2pix3d_unetvit__caax_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__zikv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_PRED_MEMB_ON_A549_caax_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__hek_mantis_kras_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__hek_mantis_kras_a549xy.yml new file mode 100644 index 000000000..f5bffff36 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__hek_mantis_kras_a549xy.yml @@ -0,0 +1,49 @@ +# pix2pix3d_unetvit predict: membrane trained on ipsc_confocal, +# predicting against the HEK293T third-cell-type probe (KRAS, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# membrane/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'pix2pix3d_unetvit' (config dir 'pix2pix3d_unetvit'). +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_kras_a549xy.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix3d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: hek_mantis_kras_a549xy + model_name: pix2pix3d_unetvit + experiment_id: membrane__ipsc_confocal__pix2pix3d_unetvit__hek_mantis_kras_a549xy + dataset_ref: + target: kras +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix3d_unetvit/checkpoints/epoch=25-step=83200.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/hek__a549xy/prediction.zarr + z_reduction: center +launcher: + job_name: PIX2PIX3D_PRED_MEMBRANE_IPSCTR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml index ae6e1a806..c5a8556ba 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=25-step=83200.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix3d_unetvit/checkpoints/epoch=25-step=83200.ckpt data: init_args: @@ -36,8 +36,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_pix2pix3d_unetvit.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/ipsc/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_PRED_MEMB - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/train.yml index 65fa7bfca..2531a20eb 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/train.yml @@ -27,6 +27,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml index 24f737c59..a48ef86bc 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml @@ -29,7 +29,7 @@ trainer: logger: init_args: name: pix2pix3d_unetvit_iPSC_MEMB_4gpu_modernized_lambdaL1_10_lecam_40ep - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix3d_unetvit callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -37,14 +37,16 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix3d_unetvit/checkpoints launcher: job_name: pix2pix3d_unetvit_iPSC_MEMB_4gpu_modernized_lambdaL1_10_lecam_40ep - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/pix2pix3d_unetvit # pix2pix3d GAN (UNetViT3D G + multiscale-patch D, large 3D crops) OOMs on # 80 GB h100; needs h200 (141 GB). Narrow the hardware_4gpu h100|h200 default. sbatch: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index 3b6ff0c9d..5cd077ae1 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -14,10 +14,14 @@ benchmark: predict_set: a549_mantis_caax_denv model_name: pix2pix3d_unetvit experiment_id: membrane__joint_ipsc_confocal_a549_mantis__pix2pix3d_unetvit__a549_mantis_caax_denv + # A549 manifest keys membrane by gene (`caax`); override the iPSC-side + # `membrane` target from targets/membrane.yml so the resolver finds caax. + dataset_ref: + target: caax model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/pix2pix3d_unetvit/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix3d_unetvit/checkpoints/epoch=35-step=192960.ckpt data: init_args: @@ -36,8 +40,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_pix2pix3d_unetvit__caax_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__denv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_JOINT_PRED_MEMB_ON_A549_caax_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index 8e8354f6f..9004e4396 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -14,10 +14,14 @@ benchmark: predict_set: a549_mantis_caax_mock model_name: pix2pix3d_unetvit experiment_id: membrane__joint_ipsc_confocal_a549_mantis__pix2pix3d_unetvit__a549_mantis_caax_mock + # A549 manifest keys membrane by gene (`caax`); override the iPSC-side + # `membrane` target from targets/membrane.yml so the resolver finds caax. + dataset_ref: + target: caax model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/pix2pix3d_unetvit/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix3d_unetvit/checkpoints/epoch=35-step=192960.ckpt data: init_args: @@ -36,8 +40,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_pix2pix3d_unetvit__caax_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__mock/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_JOINT_PRED_MEMB_ON_A549_caax_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index c1c457796..6b81a6806 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -14,10 +14,14 @@ benchmark: predict_set: a549_mantis_caax_zikv model_name: pix2pix3d_unetvit experiment_id: membrane__joint_ipsc_confocal_a549_mantis__pix2pix3d_unetvit__a549_mantis_caax_zikv + # A549 manifest keys membrane by gene (`caax`); override the iPSC-side + # `membrane` target from targets/membrane.yml so the resolver finds caax. + dataset_ref: + target: caax model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/pix2pix3d_unetvit/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix3d_unetvit/checkpoints/epoch=35-step=192960.ckpt data: init_args: @@ -36,8 +40,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/memb_pix2pix3d_unetvit__caax_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__zikv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_JOINT_PRED_MEMB_ON_A549_caax_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_kras_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_kras_a549xy.yml new file mode 100644 index 000000000..30204ab60 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_kras_a549xy.yml @@ -0,0 +1,49 @@ +# pix2pix3d_unetvit predict: membrane trained on joint_ipsc_confocal_a549_mantis, +# predicting against the HEK293T third-cell-type probe (KRAS, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'pix2pix3d_unetvit' (config dir 'pix2pix3d_unetvit'). +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_kras_a549xy.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/pix2pix3d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: hek_mantis_kras_a549xy + model_name: pix2pix3d_unetvit + experiment_id: membrane__joint_ipsc_confocal_a549_mantis__pix2pix3d_unetvit__hek_mantis_kras_a549xy + dataset_ref: + target: kras +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix3d_unetvit/checkpoints/epoch=35-step=192960.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/hek__a549xy/prediction.zarr + z_reduction: center +launcher: + job_name: PIX2PIX3D_PRED_MEMBRANE_JOINTTR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index a0aa105fd..daf4c986f 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/pix2pix3d_unetvit/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix3d_unetvit/checkpoints/epoch=35-step=192960.ckpt data: init_args: @@ -36,8 +36,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/memb_pix2pix3d_unetvit.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/ipsc/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_JOINT_PRED_MEMB_ON_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/pix2pix3d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml index f1dbc7eae..7ebd0aa65 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml @@ -31,7 +31,7 @@ trainer: logger: init_args: name: pix2pix3d_unetvit_JOINT_MEMB - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/pix2pix3d_unetvit + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix3d_unetvit callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -39,10 +39,12 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/pix2pix3d_unetvit/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix3d_unetvit/checkpoints # Child HCSDataModule init_args shared across both datasets (only data_path # differs). `_`-prefixed top-level keys are stripped by load_composed_config @@ -140,7 +142,7 @@ data: launcher: job_name: pix2pix3d_unetvit_JOINT_MEMB - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/memb/pix2pix3d_unetvit + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix3d_unetvit # Joint preloads two stores (iPSC + A549 pool) into /dev/shm; default 256G # is too tight for the iPSC marker store + A549 pool + worker overhead. sbatch: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml index 5a10f7c7b..ca26466e0 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml @@ -41,7 +41,7 @@ trainer: logger: init_args: name: pix2pix3d_unetvit_JOINT_MEMB_4gpu_modernized_lambdaL1_10_lecam_40ep - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/memb/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix3d_unetvit callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -49,10 +49,12 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/memb/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix3d_unetvit/checkpoints # Child HCSDataModule init_args shared across both datasets (only data_path # differs). `_`-prefixed top-level keys are stripped by load_composed_config @@ -150,7 +152,7 @@ data: launcher: job_name: pix2pix3d_unetvit_JOINT_MEMB_4gpu_modernized_lambdaL1_10_lecam_40ep - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/memb/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/membrane/pix2pix3d_unetvit # pix2pix3d GAN (UNetViT3D G + multiscale-patch D, large 3D crops) OOMs on # 80 GB h100; needs h200 (141 GB). Narrow the hardware_4gpu h100|h200 default. sbatch: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/a549_mantis/train.yml index 8bca97a50..27b420133 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/a549_mantis/train.yml @@ -27,6 +27,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index 3165b49cd..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Membrane (CAAX) predicted by UNetViT3D on a549-mantis-caax-denv. -# A549 manifest keys membrane by gene (`caax`); override the iPSC-side `membrane` -# target_id from the target group so the resolver finds caax on a549-mantis-caax-denv. -defaults: - - override /target: membrane - - override /predict_set: a549_mantis_caax_denv - -benchmark: - dataset_ref: - target: caax - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_unetvit3d_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_memb_unetvit3d_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index 2e3aa496c..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Membrane (CAAX) predicted by UNetViT3D on a549-mantis-caax-mock. -# A549 manifest keys membrane by gene (`caax`); override the iPSC-side `membrane` -# target_id from the target group so the resolver finds caax on a549-mantis-caax-mock. -defaults: - - override /target: membrane - - override /predict_set: a549_mantis_caax_mock - -benchmark: - dataset_ref: - target: caax - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_unetvit3d_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_memb_unetvit3d_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index dcde8c662..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Membrane (CAAX) predicted by UNetViT3D on a549-mantis-caax-zikv. -# A549 manifest keys membrane by gene (`caax`); override the iPSC-side `membrane` -# target_id from the target group so the resolver finds caax on a549-mantis-caax-zikv. -defaults: - - override /target: membrane - - override /predict_set: a549_mantis_caax_zikv - -benchmark: - dataset_ref: - target: caax - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_unetvit3d_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_memb_unetvit3d_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 100644 index 12c736435..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Membrane predicted by UNetViT3D on iPSC confocal. -defaults: - - override /target: membrane - - override /predict_set: ipsc_confocal - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_unetvit3d.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/eval_memb_unetvit3d diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml index 1aa4ee4fb..05b107bc0 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/unetvit3d/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/unetvit3d/checkpoints/epoch=18-step=121600.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_unetvit3d_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/a549__denv/prediction.zarr launcher: job_name: UNetViT3D_PRED_MEMB_ON_A549_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..b0edd4d66 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_denv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_denv_lite + model_name: unetvit3d + experiment_id: membrane__ipsc_confocal__unetvit3d__a549_mantis_caax_denv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/unetvit3d/checkpoints/epoch=18-step=121600.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/unetvit3d/ipsc/a549__denv/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_MEMB_ON_A549_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/unetvit3d/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml index 18a214e83..83071c12d 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/unetvit3d/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/unetvit3d/checkpoints/epoch=18-step=121600.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_unetvit3d_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/a549__mock/prediction.zarr launcher: job_name: UNetViT3D_PRED_MEMB_ON_A549_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..4a6841d00 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_mock_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_mock_lite + model_name: unetvit3d + experiment_id: membrane__ipsc_confocal__unetvit3d__a549_mantis_caax_mock__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/unetvit3d/checkpoints/epoch=18-step=121600.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/unetvit3d/ipsc/a549__mock/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_MEMB_ON_A549_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/unetvit3d/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml index c138f4239..7fc8500a0 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/unetvit3d/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/unetvit3d/checkpoints/epoch=18-step=121600.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/memb_unetvit3d_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/a549__zikv/prediction.zarr launcher: job_name: UNetViT3D_PRED_MEMB_ON_A549_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..802b58e4b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_caax_zikv_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: a549_mantis_caax_zikv_lite + model_name: unetvit3d + experiment_id: membrane__ipsc_confocal__unetvit3d__a549_mantis_caax_zikv__lite + dataset_ref: + target: caax +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/unetvit3d/checkpoints/epoch=18-step=121600.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/unetvit3d/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_MEMB_ON_A549_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/unetvit3d/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml index d4a42d556..f729e0daf 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/memb/unetvit3d/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/unetvit3d/checkpoints/epoch=18-step=121600.ckpt data: init_args: @@ -36,8 +36,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/memb_unetvit3d.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/ipsc/prediction.zarr launcher: job_name: UNetViT3D_PRED_MEMB - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/membrane/unetvit3d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..80982e698 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/membrane.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: membrane + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: unetvit3d + experiment_id: membrane__ipsc_confocal__unetvit3d__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/membrane/unetvit3d/checkpoints/epoch=18-step=121600.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/unetvit3d/ipsc/ipsc/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_MEMB_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/membrane/unetvit3d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/train.yml index daf2651d4..89c9427d7 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/ipsc_confocal/train.yml @@ -27,6 +27,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/joint_ipsc_confocal_a549_mantis/train.yml index 79679628f..abf7a1df1 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/membrane/unetvit3d/joint_ipsc_confocal_a549_mantis/train.yml @@ -41,6 +41,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_denv.yml index aa4bd17be..665fded2d 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_denv.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/mito_tomm20.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/tomm20/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/celldiff_r2/checkpoints/epoch=19-step=64800-v1.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_celldiff_r2_a549trained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/a549__denv/prediction.zarr launcher: job_name: CELLDiff_A549_PRED_TOMM20_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..ed98357e1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_denv_lite + model_name: celldiff + experiment_id: mito__a549_mantis__celldiff__a549_mantis_tomm20_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/celldiff_r2/checkpoints/epoch=19-step=64800-v1.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/a549/a549__denv/prediction.zarr +launcher: + job_name: CELLDiff_A549_PRED_TOMM20_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_mock.yml index 9a92e0cbe..ca98e0459 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_mock.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/mito_tomm20.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/tomm20/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/celldiff_r2/checkpoints/epoch=19-step=64800-v1.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_celldiff_r2_a549trained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/a549__mock/prediction.zarr launcher: job_name: CELLDiff_A549_PRED_TOMM20_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..b75951001 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_mock_lite + model_name: celldiff + experiment_id: mito__a549_mantis__celldiff__a549_mantis_tomm20_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/celldiff_r2/checkpoints/epoch=19-step=64800-v1.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/a549/a549__mock/prediction.zarr +launcher: + job_name: CELLDiff_A549_PRED_TOMM20_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_zikv.yml index 25cd1676b..10b8d0788 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_zikv.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/mito_tomm20.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/tomm20/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/celldiff_r2/checkpoints/epoch=19-step=64800-v1.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_celldiff_r2_a549trained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/a549__zikv/prediction.zarr launcher: job_name: CELLDiff_A549_PRED_TOMM20_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..b69a685db --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_zikv_lite + model_name: celldiff + experiment_id: mito__a549_mantis__celldiff__a549_mantis_tomm20_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/celldiff_r2/checkpoints/epoch=19-step=64800-v1.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/a549/a549__zikv/prediction.zarr +launcher: + job_name: CELLDiff_A549_PRED_TOMM20_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml new file mode 100644 index 000000000..1cc0ac1a8 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml @@ -0,0 +1,54 @@ +# celldiff predict: mito trained on a549_mantis, +# predicting against the HEK293T third-cell-type probe (TOMM70A, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# mito/celldiff/a549_mantis/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'celldiff_r2' (config dir 'celldiff'). +# z_window_size rescaled 48 -> 64 (the HEK stack depth): this model +# predicts one full-depth window per FOV, not a sliding window. +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_tomm70a_a549xy.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: hek_mantis_tomm70a_a549xy + model_name: celldiff + experiment_id: mito__a549_mantis__celldiff__hek_mantis_tomm70a_a549xy + dataset_ref: + target: tomm70a +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/celldiff_r2/checkpoints/epoch=19-step=64800-v1.ckpt + predict_method: iterative + predict_overlap: + - 4 + - 256 + - 256 +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 64 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/hek__a549xy/prediction.zarr +launcher: + job_name: CELLDIFF_PRED_MITO_A549TR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__ipsc_confocal.yml index b6ce4cd92..1a6ed5188 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__ipsc_confocal.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/mito_tomm20.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/tomm20/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/celldiff_r2/checkpoints/epoch=19-step=64800-v1.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_celldiff_r2_a549trained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/ipsc/prediction.zarr launcher: job_name: CELLDiff_A549_PRED_TOMM20_ON_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..0742f002c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: ipsc_confocal_lite + model_name: celldiff + experiment_id: mito__a549_mantis__celldiff__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/celldiff_r2/checkpoints/epoch=19-step=64800-v1.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 40 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/a549/ipsc/prediction.zarr +launcher: + job_name: CELLDiff_A549_PRED_TOMM20_ON_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/train.yml index f26b1edf9..ac7ea753c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/a549_mantis/train.yml @@ -19,7 +19,7 @@ trainer: logger: init_args: name: CELLDiff_A549_TOMM20 - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/tomm20/celldiff_r2 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/celldiff_r2 callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -29,14 +29,14 @@ trainer: every_n_epochs: 1 save_top_k: -1 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/tomm20/celldiff_r2/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/celldiff_r2/checkpoints data: init_args: # A549 pooled store + target_channel — no resolver in this train_set. target_channel: Structure - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/TOMM20_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all.zarr launcher: job_name: CELLDiff_A549_TOMM20 - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/tomm20/celldiff_r2 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/celldiff_r2 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index 9a8aec1a4..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Mitochondria (TOMM20) predicted by CellDiff on a549-mantis-tomm20-denv. -defaults: - - override /target: mito_tomm20 - - override /predict_set: a549_mantis_tomm20_denv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_celldiff_iterative__tomm20_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_tomm20_celldiff_iterative__tomm20_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index 6177c7214..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Mitochondria (TOMM20) predicted by CellDiff on a549-mantis-tomm20-mock. -defaults: - - override /target: mito_tomm20 - - override /predict_set: a549_mantis_tomm20_mock - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_celldiff_iterative__tomm20_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_tomm20_celldiff_iterative__tomm20_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index 0f28893fd..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Mitochondria (TOMM20) predicted by CellDiff on a549-mantis-tomm20-zikv. -defaults: - - override /target: mito_tomm20 - - override /predict_set: a549_mantis_tomm20_zikv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_celldiff_iterative__tomm20_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_tomm20_celldiff_iterative__tomm20_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 100644 index 7d72d571c..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Mitochondria (TOMM20) predicted by CellDiff on iPSC confocal. -defaults: - - override /target: mito_tomm20 - - override /predict_set: ipsc_confocal - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_celldiff_iterative.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/eval_tomm20_celldiff_iterative diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml index c9ee79680..2a57e73ab 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/mito_tomm20.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/tomm20/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt predict_method: iterative # denoise, generate, sliding_window, or iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_celldiff_r2_iterative__tomm20_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr launcher: job_name: CELLDiff_PRED_TOMM20_ON_A549_tomm20_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..d2cd7faab --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_denv_lite + model_name: celldiff + experiment_id: mito__ipsc_confocal__celldiff__a549_mantis_tomm20_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr +launcher: + job_name: CELLDiff_PRED_TOMM20_ON_A549_tomm20_denv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2_iterative/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml index 98e3ce246..feb9295d1 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/mito_tomm20.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/tomm20/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt predict_method: iterative # denoise, generate, sliding_window, or iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_celldiff_r2_iterative__tomm20_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr launcher: job_name: CELLDiff_PRED_TOMM20_ON_A549_tomm20_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..89dde0bfc --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_mock_lite + model_name: celldiff + experiment_id: mito__ipsc_confocal__celldiff__a549_mantis_tomm20_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr +launcher: + job_name: CELLDiff_PRED_TOMM20_ON_A549_tomm20_mock_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2_iterative/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml index de87c0bf0..310a2d556 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/mito_tomm20.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/tomm20/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt predict_method: iterative # denoise, generate, sliding_window, or iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_celldiff_r2_iterative__tomm20_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr launcher: job_name: CELLDiff_PRED_TOMM20_ON_A549_tomm20_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..079eabe60 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_zikv_lite + model_name: celldiff + experiment_id: mito__ipsc_confocal__celldiff__a549_mantis_tomm20_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: CELLDiff_PRED_TOMM20_ON_A549_tomm20_zikv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2_iterative/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__hek_mantis_tomm70a_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__hek_mantis_tomm70a_a549xy.yml new file mode 100644 index 000000000..7d388a551 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__hek_mantis_tomm70a_a549xy.yml @@ -0,0 +1,54 @@ +# celldiff predict: mito trained on ipsc_confocal, +# predicting against the HEK293T third-cell-type probe (TOMM70A, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# mito/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'celldiff_r2_iterative' (config dir 'celldiff'). +# z_window_size rescaled 48 -> 64 (the HEK stack depth): this model +# predicts one full-depth window per FOV, not a sliding window. +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_tomm70a_a549xy.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: hek_mantis_tomm70a_a549xy + model_name: celldiff + experiment_id: mito__ipsc_confocal__celldiff__hek_mantis_tomm70a_a549xy + dataset_ref: + target: tomm70a +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt + predict_method: iterative + predict_overlap: + - 4 + - 256 + - 256 +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 64 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/hek__a549xy/prediction.zarr +launcher: + job_name: CELLDIFF_PRED_MITO_IPSCTR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__ipsc_confocal__denoise.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__ipsc_confocal__denoise.yml index dc4c76c2d..15e3fb4f0 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__ipsc_confocal__denoise.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__ipsc_confocal__denoise.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/mito_tomm20.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/tomm20/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt predict_method: denoise predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_celldiff_r2_denoise.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_denoise/ipsc/ipsc/prediction.zarr launcher: job_name: CELLDiff_PRED_TOMM20_DN - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_denoise/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml index 2c1bc0b6b..0ee0c039c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/mito_tomm20.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/tomm20/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_celldiff_r2_iterative.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr launcher: job_name: CELLDiff_PRED_TOMM20_ITER - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_iterative/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative_lite.yml new file mode 100644 index 000000000..70cb1be1d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: celldiff + experiment_id: mito__ipsc_confocal__celldiff__ipsc_confocal__iterative__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 40 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr +launcher: + job_name: CELLDiff_PRED_TOMM20_ITER_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2_iterative/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__ipsc_confocal__sliding_window.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__ipsc_confocal__sliding_window.yml index 2a3c91be4..7ccde19da 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__ipsc_confocal__sliding_window.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/predict__ipsc_confocal__sliding_window.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/mito_tomm20.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/tomm20/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt predict_method: sliding_window predict_overlap: [0, 0, 0] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_celldiff_r2_sliding_window.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_sliding_window/ipsc/ipsc/prediction.zarr launcher: job_name: CELLDiff_PRED_TOMM20_SW - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2_sliding_window/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/train.yml index 5eff94452..9ced23350 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/ipsc_confocal/train.yml @@ -19,7 +19,7 @@ trainer: logger: init_args: name: CELLDiff_iPSC_TOMM20 - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/tomm20/celldiff_r2 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_r2 callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -29,8 +29,8 @@ trainer: every_n_epochs: 1 save_top_k: -1 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/tomm20/celldiff_r2/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_r2/checkpoints launcher: job_name: CELLDiff_TOMM20 - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/tomm20/celldiff_r2 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_r2 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index 6d5cb383e..bb883c299 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/mito_tomm20.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/tomm20/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/celldiff_r2/checkpoints/epoch=19-step=192800-v1.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/tomm20_celldiff_r2_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/a549__denv/prediction.zarr launcher: job_name: CELLDiff_JOINT_PRED_TOMM20_ON_A549_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..42ad1567a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_denv_lite + model_name: celldiff + experiment_id: mito__joint_ipsc_confocal_a549_mantis__celldiff__a549_mantis_tomm20_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/celldiff_r2/checkpoints/epoch=19-step=192800-v1.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/joint/a549__denv/prediction.zarr +launcher: + job_name: CELLDiff_JOINT_PRED_TOMM20_ON_A549_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index 2ea6c3e5a..471c04a49 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/mito_tomm20.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/tomm20/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/celldiff_r2/checkpoints/epoch=19-step=192800-v1.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/tomm20_celldiff_r2_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/a549__mock/prediction.zarr launcher: job_name: CELLDiff_JOINT_PRED_TOMM20_ON_A549_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..13a4a1aab --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_mock_lite + model_name: celldiff + experiment_id: mito__joint_ipsc_confocal_a549_mantis__celldiff__a549_mantis_tomm20_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/celldiff_r2/checkpoints/epoch=19-step=192800-v1.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/joint/a549__mock/prediction.zarr +launcher: + job_name: CELLDiff_JOINT_PRED_TOMM20_ON_A549_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index c27154644..1a90d816a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/mito_tomm20.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/tomm20/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/celldiff_r2/checkpoints/epoch=19-step=192800-v1.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/tomm20_celldiff_r2_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/a549__zikv/prediction.zarr launcher: job_name: CELLDiff_JOINT_PRED_TOMM20_ON_A549_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..0d724d7e6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_zikv_lite + model_name: celldiff + experiment_id: mito__joint_ipsc_confocal_a549_mantis__celldiff__a549_mantis_tomm20_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/celldiff_r2/checkpoints/epoch=19-step=192800-v1.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/joint/a549__zikv/prediction.zarr +launcher: + job_name: CELLDiff_JOINT_PRED_TOMM20_ON_A549_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml new file mode 100644 index 000000000..4ad57295f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml @@ -0,0 +1,54 @@ +# celldiff predict: mito trained on joint_ipsc_confocal_a549_mantis, +# predicting against the HEK293T third-cell-type probe (TOMM70A, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'celldiff_r2' (config dir 'celldiff'). +# z_window_size rescaled 48 -> 64 (the HEK stack depth): this model +# predicts one full-depth window per FOV, not a sliding window. +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_tomm70a_a549xy.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: hek_mantis_tomm70a_a549xy + model_name: celldiff + experiment_id: mito__joint_ipsc_confocal_a549_mantis__celldiff__hek_mantis_tomm70a_a549xy + dataset_ref: + target: tomm70a +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/celldiff_r2/checkpoints/epoch=19-step=192800-v1.ckpt + predict_method: iterative + predict_overlap: + - 4 + - 256 + - 256 +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 64 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/hek__a549xy/prediction.zarr +launcher: + job_name: CELLDIFF_PRED_MITO_JOINTTR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index 6e308b8d7..ecda84116 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/mito_tomm20.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/tomm20/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/celldiff_r2/checkpoints/epoch=19-step=192800-v1.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/tomm20_celldiff_r2.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/ipsc/prediction.zarr launcher: job_name: CELLDiff_JOINT_PRED_TOMM20_ON_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_r2/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..39a99f2f4 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal_lite + model_name: celldiff + experiment_id: mito__joint_ipsc_confocal_a549_mantis__celldiff__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/celldiff_r2/checkpoints/epoch=19-step=192800-v1.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 40 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/joint/ipsc/prediction.zarr +launcher: + job_name: CELLDiff_JOINT_PRED_TOMM20_ON_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/celldiff_r2/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/train.yml index 7c4f3ac29..a33d00839 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff/joint_ipsc_confocal_a549_mantis/train.yml @@ -29,7 +29,7 @@ trainer: logger: init_args: name: CELLDiff_JOINT_TOMM20 - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/tomm20/celldiff_r2 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/celldiff_r2 callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -39,7 +39,7 @@ trainer: every_n_epochs: 1 save_top_k: -1 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/tomm20/celldiff_r2/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/celldiff_r2/checkpoints # `_`-prefixed top-level keys are stripped by load_composed_config; see # er/celldiff_r2/joint_*/train.yml for the full anchor-convention rationale. @@ -129,11 +129,11 @@ data: - class_path: viscy_data.hcs.HCSDataModule init_args: <<: *hcs_init_args - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/TOMM20_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all.zarr launcher: job_name: CELLDiff_JOINT_TOMM20 - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/tomm20/celldiff_r2 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/celldiff_r2 # Joint preloads two stores (iPSC + A549 pool) into /dev/shm; the default # 256G cap is too tight (256G iPSC mem + ~50G A549 + worker peak OOMs). # 512G is the smallest tier that fits joint preload + worker overhead. diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..801626183 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: mito trained on a549_mantis, tested on a549-mantis-tomm20-denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_denv + model_name: celldiff_2d + experiment_id: mito__a549_mantis__celldiff_2d__a549_mantis_tomm20_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/celldiff_2d/checkpoints/epoch=19-step=9000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/a549__denv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_A549_TOMM20_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..840f1c723 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: mito trained on a549_mantis, tested on a549-mantis-tomm20-mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_mock + model_name: celldiff_2d + experiment_id: mito__a549_mantis__celldiff_2d__a549_mantis_tomm20_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/celldiff_2d/checkpoints/epoch=19-step=9000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/a549__mock/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_A549_TOMM20_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..dca775311 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: mito trained on a549_mantis, tested on a549-mantis-tomm20-zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_zikv + model_name: celldiff_2d + experiment_id: mito__a549_mantis__celldiff_2d__a549_mantis_tomm20_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/celldiff_2d/checkpoints/epoch=19-step=9000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/a549__zikv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_A549_TOMM20_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..f574f3c07 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: mito trained on a549_mantis, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: celldiff_2d + experiment_id: mito__a549_mantis__celldiff_2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/celldiff_2d/checkpoints/epoch=19-step=9000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/ipsc/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_A549_TOMM20_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/train.yml new file mode 100644 index 000000000..5e6b270d2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/a549_mantis/train.yml @@ -0,0 +1,82 @@ +# CellDiff-2D (CELLDiffNet run Z-preserving at Z=1) fit on mito (Structure +# channel) — a549_mantis, in-focus 2D track. Mirror of the 3D +# mito/celldiff/a549_mantis fit leaf, flattened onto the offline +# 5-plane in-focus slab store (z_window_size=1 emits one in-focus window +# per plane). +# +# The 3D leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus store. +# The 2D track reads the `_focus.zarr` slab instead, so the resolver is +# disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field +# co-declared with a full dataset_ref. +# +# The train_set fragment supplies data.class_path (HCSDataModule) plus +# split_ratio / mmap_preload / scratch_dir — without it the resolved +# config has an init_args-only data block and `dynacell fit` fails to +# build the datamodule. targets/mito_celldiff.yml supplies the +# MinMaxSampled(timepoint_statistics) normalization CellDiff needs +# (p1/p99 -> [-1,1], not mean/std); only its RandWeightedCropd is +# list-replaced below, flattened [13,624,624] -> [1,624,624]. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/mito_tomm20_celldiff.yml + - ../../../_internal/shared/model/data_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + gene: TOMM20 + target: mito + target_id: mito + train_set: a549_mantis + model_name: celldiff_2d + experiment_id: mito__a549_mantis__celldiff_2d + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered non-focus store. + dataset_ref: null + +data: + init_args: + # pooled TOMM20 all-conditions in-focus slab store — resolver disabled above. + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all_focus.zarr + # Flatten the target fragment's [13, 624, 624] weighted crop to Z=1. + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 624, 624] + num_samples: 2 + + +trainer: + logger: + init_args: + name: CELLDiff2D_A549_TOMM20 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/celldiff_2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + every_n_epochs: 1 + save_top_k: -1 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/celldiff_2d/checkpoints + +launcher: + job_name: CELLDiff2D_A549_TOMM20 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/celldiff_2d + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D + # store (~1/4 the Z), so the 512G headroom the 3D leaf needed for + # mmap_preload is wasteful and delays scheduling. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..e7d99c08d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: mito trained on ipsc_confocal, tested on a549-mantis-tomm20-denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_denv + model_name: celldiff_2d + experiment_id: mito__ipsc_confocal__celldiff_2d__a549_mantis_tomm20_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_2d/checkpoints/epoch=19-step=20000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_TOMM20_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..c0ffc366f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: mito trained on ipsc_confocal, tested on a549-mantis-tomm20-mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_mock + model_name: celldiff_2d + experiment_id: mito__ipsc_confocal__celldiff_2d__a549_mantis_tomm20_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_2d/checkpoints/epoch=19-step=20000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_TOMM20_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..18d6963e7 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: mito trained on ipsc_confocal, tested on a549-mantis-tomm20-zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_zikv + model_name: celldiff_2d + experiment_id: mito__ipsc_confocal__celldiff_2d__a549_mantis_tomm20_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_2d/checkpoints/epoch=19-step=20000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_TOMM20_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..578d11a65 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: mito trained on ipsc_confocal, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: celldiff_2d + experiment_id: mito__ipsc_confocal__celldiff_2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_2d/checkpoints/epoch=19-step=20000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/ipsc/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_TOMM20_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/train.yml new file mode 100644 index 000000000..7cdb26c73 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/ipsc_confocal/train.yml @@ -0,0 +1,82 @@ +# CellDiff-2D (CELLDiffNet run Z-preserving at Z=1) fit on mito (Structure +# channel) — ipsc_confocal, in-focus 2D track. Mirror of the 3D +# mito/celldiff/ipsc_confocal fit leaf, flattened onto the offline +# 5-plane in-focus slab store (z_window_size=1 emits one in-focus window +# per plane). +# +# The 3D leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus store. +# The 2D track reads the `_focus.zarr` slab instead, so the resolver is +# disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field +# co-declared with a full dataset_ref. +# +# The train_set fragment supplies data.class_path (HCSDataModule) plus +# split_ratio / mmap_preload / scratch_dir — without it the resolved +# config has an init_args-only data block and `dynacell fit` fails to +# build the datamodule. targets/mito_celldiff.yml supplies the +# MinMaxSampled(timepoint_statistics) normalization CellDiff needs +# (p1/p99 -> [-1,1], not mean/std); only its RandWeightedCropd is +# list-replaced below, flattened [13,624,624] -> [1,624,624]. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20_celldiff.yml + - ../../../_internal/shared/model/data_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + gene: TOMM20 + target: mito + target_id: mito + train_set: ipsc_confocal + model_name: celldiff_2d + experiment_id: mito__ipsc_confocal__celldiff_2d + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered non-focus store. + dataset_ref: null + +data: + init_args: + # aics-hipsc TOMM20 in-focus slab store — resolver disabled above. + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/TOMM20_focus.zarr + # Flatten the target fragment's [13, 624, 624] weighted crop to Z=1. + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 624, 624] + num_samples: 2 + + +trainer: + logger: + init_args: + name: CELLDiff2D_iPSC_TOMM20 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + every_n_epochs: 1 + save_top_k: -1 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_2d/checkpoints + +launcher: + job_name: CELLDiff2D_TOMM20 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/celldiff_2d + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D + # store (~1/4 the Z), so the 512G headroom the 3D leaf needed for + # mmap_preload is wasteful and delays scheduling. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..1d6962910 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: mito trained on joint_ipsc_confocal_a549_mantis, tested on a549-mantis-tomm20-denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_denv + model_name: celldiff_2d + experiment_id: mito__joint_ipsc_confocal_a549_mantis__celldiff_2d__a549_mantis_tomm20_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/celldiff_2d/checkpoints/epoch=19-step=29240.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/a549__denv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_JOINT_TOMM20_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..fe34b6b08 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: mito trained on joint_ipsc_confocal_a549_mantis, tested on a549-mantis-tomm20-mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_mock + model_name: celldiff_2d + experiment_id: mito__joint_ipsc_confocal_a549_mantis__celldiff_2d__a549_mantis_tomm20_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/celldiff_2d/checkpoints/epoch=19-step=29240.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/a549__mock/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_JOINT_TOMM20_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..6fec43fdf --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: mito trained on joint_ipsc_confocal_a549_mantis, tested on a549-mantis-tomm20-zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_zikv + model_name: celldiff_2d + experiment_id: mito__joint_ipsc_confocal_a549_mantis__celldiff_2d__a549_mantis_tomm20_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/celldiff_2d/checkpoints/epoch=19-step=29240.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/a549__zikv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_JOINT_TOMM20_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..70f257d72 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: mito trained on joint_ipsc_confocal_a549_mantis, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: celldiff_2d + experiment_id: mito__joint_ipsc_confocal_a549_mantis__celldiff_2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/celldiff_2d/checkpoints/epoch=19-step=29240.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/ipsc/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_JOINT_TOMM20_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/celldiff_2d/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..54dbc681e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/celldiff_2d/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,138 @@ +# CellDiff-2D (CELLDiffNet run Z-preserving at Z=1) fit on mito (Structure) +# — joint ipsc_confocal + a549_mantis pooled, in-focus 2D track. Mirror of +# the 3D mito/celldiff/joint_* fit leaf, flattened onto the offline +# 5-plane in-focus slab stores. +# +# BatchedConcatDataModule + two explicit HCSDataModule children; only +# model_overlays/celldiff_2d_fit.yml is composed (the data block is +# authored inline here, not via data_overlays). +# +# batch_size 2 here, NOT the single-set 4: BatchedConcatDataModule's +# train_dataloader uses batch_size as-is, while HCSDataModule divides by +# RandWeightedCropd num_samples. 2 indices * 2 num_samples = 4 GPU +# samples, matching the single-set leaves. +base: + - ../../../_internal/shared/model/model_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + gene: TOMM20 + target: mito + target_id: mito + train_set: joint_ipsc_confocal_a549_mantis + model_name: celldiff_2d + experiment_id: mito__joint_ipsc_confocal_a549_mantis__celldiff_2d + +trainer: + logger: + init_args: + name: CELLDiff2D_JOINT_TOMM20 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/celldiff_2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + every_n_epochs: 1 + save_top_k: -1 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/celldiff_2d/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Structure + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: [512, 512] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Structure] + level: timepoint_statistics + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 624, 624] + num_samples: 2 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [0, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[1, 1], [0.5, 1.5], [0.5, 1.5]] + safe_crop_size: [1, 512, 512] + safe_crop_coverage: 0.9 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0, 0] + val_gpu_augmentations: + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] + + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc TOMM20 in-focus slab store + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/TOMM20_focus.zarr + # a549_mantis — pooled TOMM20 all-conditions in-focus slab store + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all_focus.zarr + +launcher: + job_name: CELLDiff2D_JOINT_TOMM20 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/celldiff_2d + # 128G: both children preload 5-plane in-focus slabs (~1/4 the Z of the + # 3D stores), so the 512G the 3D joint leaf needed is wasteful here. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..191ea1655 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: mito trained on a549_mantis, +# tested on a549-mantis-tomm20-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_denv + model_name: fcmae_vscyto2d_pretrained + experiment_id: mito__a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_tomm20_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto2d_pretrained/checkpoints/epoch=23-step=5232-loss=0.735.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_A549TR_TOMM20_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..6aa6a7073 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: mito trained on a549_mantis, +# tested on a549-mantis-tomm20-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_mock + model_name: fcmae_vscyto2d_pretrained + experiment_id: mito__a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_tomm20_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto2d_pretrained/checkpoints/epoch=23-step=5232-loss=0.735.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_A549TR_TOMM20_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..cbc7d831a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: mito trained on a549_mantis, +# tested on a549-mantis-tomm20-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_zikv + model_name: fcmae_vscyto2d_pretrained + experiment_id: mito__a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_tomm20_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto2d_pretrained/checkpoints/epoch=23-step=5232-loss=0.735.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_A549TR_TOMM20_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..d581336ae --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: mito trained on a549_mantis, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_pretrained + experiment_id: mito__a549_mantis__fcmae_vscyto2d_pretrained__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto2d_pretrained/checkpoints/epoch=23-step=5232-loss=0.735.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_A549TR_TOMM20_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/train.yml new file mode 100644 index 000000000..aed766a19 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/a549_mantis/train.yml @@ -0,0 +1,73 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) with FCMAE-2D +# pretrained encoder init on mito/TOMM20, in-focus 2D benchmark track, +# A549 mantis pooled (mock + DENV + ZIKV). Paper key: VSCyto2D. Companion +# to fcmae_vscyto2d_scratch — the two leaves are identical except this one +# loads the 2D FCMAE encoder weights and drops lr to 0.0002 (mirroring +# cytoland VSCyto2D finetuning). +# +# Reads the offline 5-plane in-focus slab store TOMM20_all_focus.zarr +# (z_window_size=1 emits one in-focus window per plane). target_channel +# "Structure" matches the FCMAE-2D data overlay's default augmentation +# keys, so no augmentation override is needed. Mirror of the 3D +# mito/fcmae_vscyto3d_pretrained/a549_mantis fit leaf. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + train_set: a549_mantis + model_name: fcmae_vscyto2d_pretrained + experiment_id: mito__a549_mantis__fcmae_vscyto2d_pretrained + +model: + init_args: + # Load only the encoder from the 2D FCMAE ckpt (400 ep on HEK + A549 + + # BJ5a + LIVECell + CTMC phase data); decoder/head stay at fresh init. + # lr 0.0002 overrides the overlay's 0.0004 for pretrained finetuning. + encoder_only: true + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/fcmae-2d/pretrain-logs/hek-a549-bj5a-livecell-ctmc-400ep/checkpoints/last.ckpt + lr: 0.0002 + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Pretrained_A549_TOMM20_ws8500 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto2d_pretrained + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto2d_pretrained/checkpoints + +data: + init_args: + # A549 pooled in-focus slab store + target_channel — no resolver in + # this train_set. + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all_focus.zarr + +launcher: + job_name: FCMAE_VSCyto2D_Pretrained_A549_TOMM20_ws8500 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto2d_pretrained + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..77d08b4cf --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: mito trained on ipsc_confocal, +# tested on a549-mantis-tomm20-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_denv + model_name: fcmae_vscyto2d_pretrained + experiment_id: mito__ipsc_confocal__fcmae_vscyto2d_pretrained__a549_mantis_tomm20_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto2d_pretrained/checkpoints/epoch=4-step=2500-loss=0.727.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_TOMM20_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..20e9a3126 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: mito trained on ipsc_confocal, +# tested on a549-mantis-tomm20-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_mock + model_name: fcmae_vscyto2d_pretrained + experiment_id: mito__ipsc_confocal__fcmae_vscyto2d_pretrained__a549_mantis_tomm20_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto2d_pretrained/checkpoints/epoch=4-step=2500-loss=0.727.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_TOMM20_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..64e1ad3e6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: mito trained on ipsc_confocal, +# tested on a549-mantis-tomm20-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_zikv + model_name: fcmae_vscyto2d_pretrained + experiment_id: mito__ipsc_confocal__fcmae_vscyto2d_pretrained__a549_mantis_tomm20_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto2d_pretrained/checkpoints/epoch=4-step=2500-loss=0.727.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_TOMM20_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..3a6aa7006 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: mito trained on ipsc_confocal, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_pretrained + experiment_id: mito__ipsc_confocal__fcmae_vscyto2d_pretrained__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto2d_pretrained/checkpoints/epoch=4-step=2500-loss=0.727.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_TOMM20_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/train.yml new file mode 100644 index 000000000..d7c230ffe --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/ipsc_confocal/train.yml @@ -0,0 +1,83 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) with FCMAE-2D +# pretrained encoder init on mito/TOMM20, in-focus 2D benchmark track, +# iPSC confocal (aics-hipsc). Paper key: VSCyto2D. Companion to +# fcmae_vscyto2d_scratch — the two leaves are identical except this one +# loads the 2D FCMAE encoder weights and drops lr to 0.0002 (mirroring +# cytoland VSCyto2D finetuning). +# +# The 3D ipsc leaf resolves data_path/source_channel/target_channel from +# the manifest via benchmark.dataset_ref, which points at the NON-focus +# TOMM20.zarr. The 2D track reads the offline 5-plane in-focus slab store +# TOMM20_focus.zarr instead, so the resolver is disabled here +# (dataset_ref: null) and the three data fields are declared inline — the +# resolver hook raises on any data.init_args field co-declared with a full +# dataset_ref. source_channel/target_channel reproduce the resolver's +# manifest output (Phase3D / Structure). target_channel "Structure" also +# matches the FCMAE-2D data overlay's default augmentation keys, so no +# augmentation override is needed. Mirror of the 3D +# mito/fcmae_vscyto3d_pretrained/ipsc_confocal fit leaf. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + train_set: ipsc_confocal + model_name: fcmae_vscyto2d_pretrained + experiment_id: mito__ipsc_confocal__fcmae_vscyto2d_pretrained + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered TOMM20.zarr. dataset_ref: null makes + # the compose hook a no-op so data fields can be declared inline. + dataset_ref: null + +data: + init_args: + # iPSC in-focus slab store + channels — resolver disabled above. + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/TOMM20_focus.zarr + +model: + init_args: + # Load only the encoder from the 2D FCMAE ckpt (400 ep on HEK + A549 + + # BJ5a + LIVECell + CTMC phase data); decoder/head stay at fresh init. + # lr 0.0002 overrides the overlay's 0.0004 for pretrained finetuning. + encoder_only: true + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/fcmae-2d/pretrain-logs/hek-a549-bj5a-livecell-ctmc-400ep/checkpoints/last.ckpt + lr: 0.0002 + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Pretrained_iPSC_TOMM20_ws8500 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto2d_pretrained + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto2d_pretrained/checkpoints + +launcher: + job_name: FCMAE_VSCyto2D_Pretrained_TOMM20_ws8500 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto2d_pretrained + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..f97ba321e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: mito trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-tomm20-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_denv + model_name: fcmae_vscyto2d_pretrained + experiment_id: mito__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_tomm20_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto2d_pretrained/checkpoints/epoch=5-step=4308-loss=0.741.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_JOINT_TOMM20_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..b5a950cc7 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: mito trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-tomm20-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_mock + model_name: fcmae_vscyto2d_pretrained + experiment_id: mito__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_tomm20_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto2d_pretrained/checkpoints/epoch=5-step=4308-loss=0.741.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_JOINT_TOMM20_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..71c62dda0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: mito trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-tomm20-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_zikv + model_name: fcmae_vscyto2d_pretrained + experiment_id: mito__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_tomm20_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto2d_pretrained/checkpoints/epoch=5-step=4308-loss=0.741.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_JOINT_TOMM20_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..f0be4eb26 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: mito trained on joint_ipsc_confocal_a549_mantis, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_pretrained + experiment_id: mito__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto2d_pretrained/checkpoints/epoch=5-step=4308-loss=0.741.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_JOINT_TOMM20_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_pretrained/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..9094623ae --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,165 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) with FCMAE-2D +# pretrained encoder init on mito (TOMM20) — joint +# ipsc_confocal + a549_mantis pooled, in-focus 2D benchmark track. +# Paper key: VSCyto2D. Companion to the fcmae_vscyto2d_scratch joint +# leaf — the two are identical except this one loads the 2D FCMAE +# encoder weights and drops lr to 0.0002 (mirroring cytoland VSCyto2D +# finetuning). Mirrors mito/fcmae_vscyto2d_pretrained/ipsc_confocal on +# the joint train_set, flattened to the 2D focus-slab geometry. +# +# Joint leaf: BatchedConcatDataModule with two explicit HCSDataModule +# children (no benchmark.dataset_ref — joint leaves bypass the single- +# dataset resolver, so both child data_paths are the offline +# `_focus.zarr` slab stores directly). Only +# model_overlays/fcmae_vscyto2d_fit.yml is composed; the data block is +# authored inline because joint hparams live on the children. +# +# Topology: single-GPU (inherited from model_overlays/fcmae_vscyto2d_fit.yml +# single_gpu base). z_window_size=1 reads one in-focus plane per window; +# BatchedConcatDataModule does NOT divide batch_size by num_samples, so +# batch_size=4 * num_samples=4 = 16 GPU samples/step, matching the +# single-set 2D data overlay's effective 16. +base: + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + gene: TOMM20 + target: mito + target_id: mito_tomm20 + train_set: joint_ipsc_confocal_a549_mantis + model_name: fcmae_vscyto2d_pretrained + experiment_id: mito__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained + +model: + init_args: + # Load only the encoder from the 2D FCMAE ckpt (400 ep on HEK + A549 + + # BJ5a + LIVECell + CTMC phase data); decoder/head stay at fresh init. + # lr 0.0002 overrides the overlay's 0.0004 for pretrained finetuning. + encoder_only: true + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/fcmae-2d/pretrain-logs/hek-a549-bj5a-livecell-ctmc-400ep/checkpoints/last.ckpt + lr: 0.0002 + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Pretrained_JOINT_TOMM20_ws8500 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto2d_pretrained + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto2d_pretrained/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Structure + z_window_size: 1 + # batch_size is NOT divided by num_samples in joint mode: 4 indices * + # num_samples=4 = 16 GPU samples per rank, matching the single-set 2D + # data overlay's effective 16. + batch_size: 4 + num_workers: 4 + yx_patch_size: [384, 384] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Structure] + level: fov_statistics + subtrahend: median + divisor: iqr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 600, 600] + num_samples: 4 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [0, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[1, 1], [0.5, 1.5], [0.5, 1.5]] + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 384, 384] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0, 0] + val_gpu_augmentations: + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 384, 384] + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc TOMM20 in-focus slab + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/TOMM20_focus.zarr + # a549_mantis — pooled TOMM20 in-focus slab + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all_focus.zarr + +launcher: + job_name: FCMAE_VSCyto2D_Pretrained_JOINT_TOMM20_ws8500 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto2d_pretrained + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..7347ca412 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: mito trained on a549_mantis, +# tested on a549-mantis-tomm20-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_denv + model_name: fcmae_vscyto2d_scratch + experiment_id: mito__a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_tomm20_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto2d_scratch/checkpoints/epoch=31-step=6976-loss=0.828.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_A549TR_TOMM20_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..07ff7d16e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: mito trained on a549_mantis, +# tested on a549-mantis-tomm20-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_mock + model_name: fcmae_vscyto2d_scratch + experiment_id: mito__a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_tomm20_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto2d_scratch/checkpoints/epoch=31-step=6976-loss=0.828.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_A549TR_TOMM20_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..5356040b1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: mito trained on a549_mantis, +# tested on a549-mantis-tomm20-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_zikv + model_name: fcmae_vscyto2d_scratch + experiment_id: mito__a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_tomm20_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto2d_scratch/checkpoints/epoch=31-step=6976-loss=0.828.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_A549TR_TOMM20_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..81951c8c2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: mito trained on a549_mantis, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch + experiment_id: mito__a549_mantis__fcmae_vscyto2d_scratch__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto2d_scratch/checkpoints/epoch=31-step=6976-loss=0.828.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_A549TR_TOMM20_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/train.yml new file mode 100644 index 000000000..d90d231c5 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/a549_mantis/train.yml @@ -0,0 +1,64 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) random-init baseline +# on mito/TOMM20, in-focus 2D benchmark track, A549 mantis pooled +# (mock + DENV + ZIKV). Scratch control for the fcmae_vscyto2d_pretrained +# (VSCyto2D) counterpart — the two leaves are identical except this one +# does NOT load pretrained encoder weights. +# +# Reads the offline 5-plane in-focus slab store TOMM20_all_focus.zarr +# (extracted from the 3D TOMM20_all.zarr; z_window_size=1 emits one +# in-focus window per plane). Mirror of the 3D +# mito/fcmae_vscyto3d_scratch/a549_mantis fit leaf. target_channel == +# "Structure" matches the FCMAE-2D data overlay's RandWeightedCropd keys, +# so no augmentation override is needed here. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + train_set: a549_mantis + model_name: fcmae_vscyto2d_scratch + experiment_id: mito__a549_mantis__fcmae_vscyto2d_scratch + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Scratch_A549_TOMM20 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto2d_scratch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto2d_scratch/checkpoints + +data: + init_args: + # A549 pooled in-focus slab store + target_channel — no resolver in + # this train_set. + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all_focus.zarr + +launcher: + job_name: FCMAE_VSCyto2D_Scratch_A549_TOMM20 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto2d_scratch + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..a74d4b6b9 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: mito trained on ipsc_confocal, +# tested on a549-mantis-tomm20-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_denv + model_name: fcmae_vscyto2d_scratch + experiment_id: mito__ipsc_confocal__fcmae_vscyto2d_scratch__a549_mantis_tomm20_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto2d_scratch/checkpoints/epoch=8-step=4500-loss=0.743.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_TOMM20_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..3a968b3f6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: mito trained on ipsc_confocal, +# tested on a549-mantis-tomm20-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_mock + model_name: fcmae_vscyto2d_scratch + experiment_id: mito__ipsc_confocal__fcmae_vscyto2d_scratch__a549_mantis_tomm20_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto2d_scratch/checkpoints/epoch=8-step=4500-loss=0.743.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_TOMM20_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..980ae1afb --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: mito trained on ipsc_confocal, +# tested on a549-mantis-tomm20-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_zikv + model_name: fcmae_vscyto2d_scratch + experiment_id: mito__ipsc_confocal__fcmae_vscyto2d_scratch__a549_mantis_tomm20_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto2d_scratch/checkpoints/epoch=8-step=4500-loss=0.743.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_TOMM20_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..bf214c912 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: mito trained on ipsc_confocal, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch + experiment_id: mito__ipsc_confocal__fcmae_vscyto2d_scratch__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto2d_scratch/checkpoints/epoch=8-step=4500-loss=0.743.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_TOMM20_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml new file mode 100644 index 000000000..53cf31102 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml @@ -0,0 +1,72 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) random-init baseline +# on mito/TOMM20, in-focus 2D benchmark track, iPSC confocal. Scratch +# control for the fcmae_vscyto2d_pretrained (VSCyto2D) counterpart — the +# two leaves are identical except this one does NOT load pretrained encoder +# weights. Mirror of the 3D mito/fcmae_vscyto3d_scratch/ipsc_confocal fit +# leaf. target_channel == "Structure" matches the FCMAE-2D data overlay's +# RandWeightedCropd keys, so no augmentation override is needed here. +# +# The 3D ipsc leaf resolves data_path/source_channel/target_channel from +# the manifest via benchmark.dataset_ref, which points at the NON-focus +# TOMM20.zarr. The 2D track reads the offline 5-plane in-focus slab store +# TOMM20_focus.zarr instead, so the resolver is disabled here +# (dataset_ref: null) and the three data fields are declared inline — +# the resolver hook raises on any data.init_args field co-declared with a +# full dataset_ref. source_channel/target_channel reproduce the resolver's +# manifest output (Phase3D / Structure). +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + train_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch + experiment_id: mito__ipsc_confocal__fcmae_vscyto2d_scratch + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered TOMM20.zarr. dataset_ref: null makes + # the compose hook a no-op so data fields can be declared inline. + dataset_ref: null + +data: + init_args: + # iPSC in-focus slab store + channels — resolver disabled above. + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/TOMM20_focus.zarr + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Scratch_iPSC_TOMM20 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto2d_scratch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto2d_scratch/checkpoints + +launcher: + job_name: FCMAE_VSCyto2D_Scratch_TOMM20 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto2d_scratch + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..6b4355161 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: mito trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-tomm20-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_denv + model_name: fcmae_vscyto2d_scratch + experiment_id: mito__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_tomm20_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto2d_scratch/checkpoints/epoch=14-step=10770-loss=0.775.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_JOINT_TOMM20_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..4b84dcb1f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: mito trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-tomm20-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_mock + model_name: fcmae_vscyto2d_scratch + experiment_id: mito__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_tomm20_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto2d_scratch/checkpoints/epoch=14-step=10770-loss=0.775.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_JOINT_TOMM20_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..d4717a696 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: mito trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-tomm20-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_zikv + model_name: fcmae_vscyto2d_scratch + experiment_id: mito__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_tomm20_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto2d_scratch/checkpoints/epoch=14-step=10770-loss=0.775.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_JOINT_TOMM20_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..c49f3f1df --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: mito trained on joint_ipsc_confocal_a549_mantis, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch + experiment_id: mito__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto2d_scratch/checkpoints/epoch=14-step=10770-loss=0.775.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_JOINT_TOMM20_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto2d_scratch/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..bd272f762 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,150 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) random-init baseline +# on mito (TOMM20), in-focus 2D benchmark track — joint ipsc_confocal + +# a549_mantis pooled. Scratch control for the fcmae_vscyto2d_pretrained +# (VSCyto2D) counterpart — the two leaves are identical except this one +# does NOT load pretrained encoder weights. Mirrors +# mito/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml on the joint +# train_set and the 3D mito/fcmae_vscyto3d_scratch/joint_* leaf. +# +# Joint leaf: BatchedConcatDataModule + two explicit HCSDataModule +# children; only model_overlays/fcmae_vscyto2d_fit.yml is composed (the +# data overlay is NOT — the data block is inlined via the &hcs_init_args +# anchor). Both children read the offline 5-plane in-focus slab stores +# (z_window_size=1). Single-GPU topology (from the 2D model overlay + +# hardware_gpu_any_long), so no DDP block. +base: + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + gene: TOMM20 + target: mito + target_id: mito_tomm20 + train_set: joint_ipsc_confocal_a549_mantis + model_name: fcmae_vscyto2d_scratch + experiment_id: mito__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Scratch_JOINT_TOMM20 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto2d_scratch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto2d_scratch/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Structure + z_window_size: 1 + # Joint mode does not divide batch_size by num_samples, so 4 * 4 = 16 GPU + # samples per step matches the single-set 2D overlay's effective batch + # (batch_size 16). Halved from the 3D joint's 8 to fit the single-GPU + # 48 GB pool (a40|l40s|a6000) that the 2D track targets. + batch_size: 4 + num_workers: 4 + yx_patch_size: [384, 384] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Structure] + level: fov_statistics + subtrahend: median + divisor: iqr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 600, 600] + num_samples: 4 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [0, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[1, 1], [0.5, 1.5], [0.5, 1.5]] + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 384, 384] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0, 0] + val_gpu_augmentations: + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 384, 384] + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc TOMM20 in-focus slab store + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/TOMM20_focus.zarr + # a549_mantis — pooled TOMM20 all-conditions in-focus slab store + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all_focus.zarr + +launcher: + job_name: FCMAE_VSCyto2D_Scratch_JOINT_TOMM20 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto2d_scratch + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_denv.yml index 736ada20d..bad62c01a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_denv.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/mito_tomm20.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_mock.yml index 461364208..2de04aebb 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_mock.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/mito_tomm20.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_zikv.yml index d94a378d1..624c717f2 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_zikv.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/mito_tomm20.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__ipsc_confocal.yml index bb39acbf3..46ce379ec 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__ipsc_confocal.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/mito_tomm20.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml index ba8a8e906..479a4be60 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=139-step=22120.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=115-step=18328.ckpt data: init_args: @@ -40,8 +40,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained_a549trained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20_A549TR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..9f3820ba1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_denv_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: mito__a549_mantis__fcmae_vscyto3d_pretrained__a549_mantis_tomm20_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=115-step=18328.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20_A549TR_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml index bf536a7a7..90b599de7 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=139-step=22120.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=115-step=18328.ckpt data: init_args: @@ -40,8 +40,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained_a549trained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20_A549TR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..11198162f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_mock_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: mito__a549_mantis__fcmae_vscyto3d_pretrained__a549_mantis_tomm20_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=115-step=18328.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20_A549TR_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml index 92dbdd60b..11b443115 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=139-step=22120.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=115-step=18328.ckpt data: init_args: @@ -40,8 +40,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained_a549trained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20_A549TR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..dd480bc51 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_zikv_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: mito__a549_mantis__fcmae_vscyto3d_pretrained__a549_mantis_tomm20_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=115-step=18328.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20_A549TR_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml new file mode 100644 index 000000000..10b69cfeb --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml @@ -0,0 +1,48 @@ +# fcmae_vscyto3d_pretrained predict: mito trained on a549_mantis, +# predicting against the HEK293T third-cell-type probe (TOMM70A, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'fcmae_vscyto3d_pretrained' (config dir 'fcmae_vscyto3d_pretrained'). +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_tomm70a_a549xy.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: hek_mantis_tomm70a_a549xy + model_name: fcmae_vscyto3d_pretrained + experiment_id: mito__a549_mantis__fcmae_vscyto3d_pretrained__hek_mantis_tomm70a_a549xy + dataset_ref: + target: tomm70a +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=115-step=18328.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/hek__a549xy/prediction.zarr +launcher: + job_name: VSCYTO3D_PRED_MITO_A549TR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml index dee598e4f..255766b09 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=139-step=22120.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=115-step=18328.ckpt data: init_args: @@ -40,8 +40,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_fcmae_vscyto3d_pretrained_a549trained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20_A549TR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..af7f060ff --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: ipsc_confocal_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: mito__a549_mantis__fcmae_vscyto3d_pretrained__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=115-step=18328.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20_A549TR_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/train.yml index f19f0f1a6..d37138235 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/a549_mantis/train.yml @@ -31,7 +31,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Pretrained_A549_TOMM20_ws8500 - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fcmae_vscyto3d_pretrained_ws8500 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_pretrained callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -39,17 +39,19 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fcmae_vscyto3d_pretrained_ws8500/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_pretrained/checkpoints data: init_args: # A549 pooled store + target_channel — no resolver in this train_set. target_channel: Structure - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/TOMM20_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_A549_TOMM20_ws8500 - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fcmae_vscyto3d_pretrained_ws8500 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_pretrained diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index 90120fc4d..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Mitochondria (TOMM20) predicted by FCMAE_VSCyto3D_Pretrained on a549-mantis-tomm20-denv. -defaults: - - override /target: mito_tomm20 - - override /predict_set: a549_mantis_tomm20_denv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained__tomm20_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_tomm20_fcmae_vscyto3d_pretrained__tomm20_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index 6b6619ebf..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Mitochondria (TOMM20) predicted by FCMAE_VSCyto3D_Pretrained on a549-mantis-tomm20-mock. -defaults: - - override /target: mito_tomm20 - - override /predict_set: a549_mantis_tomm20_mock - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained__tomm20_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_tomm20_fcmae_vscyto3d_pretrained__tomm20_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index d20c1d11d..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Mitochondria (TOMM20) predicted by FCMAE_VSCyto3D_Pretrained on a549-mantis-tomm20-zikv. -defaults: - - override /target: mito_tomm20 - - override /predict_set: a549_mantis_tomm20_zikv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained__tomm20_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_tomm20_fcmae_vscyto3d_pretrained__tomm20_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml index 9690f1f06..23302957f 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=58-step=18408.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=58-step=18408.ckpt data: init_args: @@ -40,8 +40,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained__tomm20_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20_ON_A549_tomm20_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..b560a57ca --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_denv_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: mito__ipsc_confocal__fcmae_vscyto3d_pretrained__a549_mantis_tomm20_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=58-step=18408.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20_ON_A549_tomm20_denv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml index 3f50d6514..33cae0aee 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=58-step=18408.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=58-step=18408.ckpt data: init_args: @@ -40,8 +40,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained__tomm20_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20_ON_A549_tomm20_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..7c7262ff0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_mock_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: mito__ipsc_confocal__fcmae_vscyto3d_pretrained__a549_mantis_tomm20_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=58-step=18408.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20_ON_A549_tomm20_mock_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml index 010cd8c66..e69b9d154 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=58-step=18408.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=58-step=18408.ckpt data: init_args: @@ -40,8 +40,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained__tomm20_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20_ON_A549_tomm20_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..2046e4e0b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_zikv_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: mito__ipsc_confocal__fcmae_vscyto3d_pretrained__a549_mantis_tomm20_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=58-step=18408.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20_ON_A549_tomm20_zikv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__hek_mantis_tomm70a_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__hek_mantis_tomm70a_a549xy.yml new file mode 100644 index 000000000..79f695895 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__hek_mantis_tomm70a_a549xy.yml @@ -0,0 +1,48 @@ +# fcmae_vscyto3d_pretrained predict: mito trained on ipsc_confocal, +# predicting against the HEK293T third-cell-type probe (TOMM70A, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'fcmae_vscyto3d_pretrained' (config dir 'fcmae_vscyto3d_pretrained'). +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_tomm70a_a549xy.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: hek_mantis_tomm70a_a549xy + model_name: fcmae_vscyto3d_pretrained + experiment_id: mito__ipsc_confocal__fcmae_vscyto3d_pretrained__hek_mantis_tomm70a_a549xy + dataset_ref: + target: tomm70a +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=58-step=18408.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/hek__a549xy/prediction.zarr +launcher: + job_name: VSCYTO3D_PRED_MITO_IPSCTR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml index d5d15fc0e..ac740a374 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=58-step=18408.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=58-step=18408.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_fcmae_vscyto3d_pretrained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20 - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..82f816d35 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: mito__ipsc_confocal__fcmae_vscyto3d_pretrained__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=58-step=18408.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_pretrained/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/train.yml index 57c1002ff..ac2b8af6b 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/ipsc_confocal/train.yml @@ -31,7 +31,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Pretrained_iPSC_TOMM20_ws8500 - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fcmae_vscyto3d_pretrained_ws8500 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_pretrained callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -39,11 +39,13 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fcmae_vscyto3d_pretrained_ws8500/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_pretrained/checkpoints launcher: job_name: FCMAE_VSCyto3D_Pretrained_TOMM20_ws8500 - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fcmae_vscyto3d_pretrained_ws8500 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_pretrained diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index 502dffeea..f2b762039 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=43-step=21120.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=80-step=38880-loss=0.534.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained_jointtrained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20_JOINTTR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index 7ef48b025..37df6a180 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=43-step=21120.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=80-step=38880-loss=0.534.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained_jointtrained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20_JOINTTR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index f7444295d..98f3a7ae0 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=43-step=21120.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=80-step=38880-loss=0.534.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_pretrained_jointtrained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20_JOINTTR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml new file mode 100644 index 000000000..9fc59b817 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml @@ -0,0 +1,48 @@ +# fcmae_vscyto3d_pretrained predict: mito trained on joint_ipsc_confocal_a549_mantis, +# predicting against the HEK293T third-cell-type probe (TOMM70A, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'fcmae_vscyto3d_pretrained' (config dir 'fcmae_vscyto3d_pretrained'). +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_tomm70a_a549xy.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: hek_mantis_tomm70a_a549xy + model_name: fcmae_vscyto3d_pretrained + experiment_id: mito__joint_ipsc_confocal_a549_mantis__fcmae_vscyto3d_pretrained__hek_mantis_tomm70a_a549xy + dataset_ref: + target: tomm70a +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=80-step=38880-loss=0.534.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/hek__a549xy/prediction.zarr +launcher: + job_name: VSCYTO3D_PRED_MITO_JOINTTR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index 0ed74c32d..c96306cd8 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -27,7 +27,7 @@ model: # ckpt lives under the _ws8500 training-output subdir; config namespace # uses fcmae_vscyto3d_pretrained (no _ws8500 suffix) for consistency with # iPSC + a549 single-set predict configs. - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fcmae_vscyto3d_pretrained_ws8500/checkpoints/epoch=43-step=21120.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto3d_pretrained/checkpoints/epoch=80-step=38880-loss=0.534.ckpt data: init_args: @@ -44,8 +44,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_fcmae_vscyto3d_pretrained_jointtrained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_TOMM20_JOINTTR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_pretrained/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml index d7241e6bd..6a920b270 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml @@ -22,7 +22,7 @@ base: - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_fit.yml - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu_long.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -46,7 +46,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Pretrained_JOINT_TOMM20_ws8500 - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fcmae_vscyto3d_pretrained_ws8500 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto3d_pretrained callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -54,10 +54,12 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fcmae_vscyto3d_pretrained_ws8500/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto3d_pretrained/checkpoints _hcs_init_args: &hcs_init_args source_channel: Phase3D @@ -147,8 +149,8 @@ data: - class_path: viscy_data.hcs.HCSDataModule init_args: <<: *hcs_init_args - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/TOMM20_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_JOINT_TOMM20_ws8500 - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fcmae_vscyto3d_pretrained_ws8500 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto3d_pretrained diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml index 6e7673faa..14e32915f 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml @@ -24,7 +24,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fcmae_vscyto3d_scratch/checkpoints/epoch=113-step=18012.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=167-step=26544.ckpt data: init_args: @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch_a549trained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20_A549TR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..a66fe142f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_denv_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: mito__a549_mantis__fcmae_vscyto3d_scratch__a549_mantis_tomm20_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=167-step=26544.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20_A549TR_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml index 0d387ad05..6394300ce 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml @@ -24,7 +24,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fcmae_vscyto3d_scratch/checkpoints/epoch=113-step=18012.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=167-step=26544.ckpt data: init_args: @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch_a549trained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20_A549TR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..29b15f210 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_mock_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: mito__a549_mantis__fcmae_vscyto3d_scratch__a549_mantis_tomm20_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=167-step=26544.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20_A549TR_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml index f6c59d636..f3cb6c9a2 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml @@ -24,7 +24,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fcmae_vscyto3d_scratch/checkpoints/epoch=113-step=18012.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=167-step=26544.ckpt data: init_args: @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch_a549trained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20_A549TR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..18787c485 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_zikv_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: mito__a549_mantis__fcmae_vscyto3d_scratch__a549_mantis_tomm20_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=167-step=26544.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20_A549TR_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml index ec3830537..e64411262 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml @@ -29,7 +29,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fcmae_vscyto3d_scratch/checkpoints/epoch=113-step=18012.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=167-step=26544.ckpt data: init_args: @@ -46,8 +46,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_fcmae_vscyto3d_scratch_a549trained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20_A549TR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..9bed937a6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: ipsc_confocal_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: mito__a549_mantis__fcmae_vscyto3d_scratch__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=167-step=26544.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20_A549TR_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/train.yml index 98e99984a..8f6af9d6c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/a549_mantis/train.yml @@ -22,7 +22,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Scratch_A549_TOMM20 - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fcmae_vscyto3d_scratch + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_scratch callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -30,17 +30,19 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fcmae_vscyto3d_scratch/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_scratch/checkpoints data: init_args: # A549 pooled store + target_channel — no resolver in this train_set. target_channel: Structure - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/TOMM20_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_A549_TOMM20 - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fcmae_vscyto3d_scratch + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fcmae_vscyto3d_scratch diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index a0e9ba367..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Mitochondria (TOMM20) predicted by FCMAE_VSCyto3D_Scratch on a549-mantis-tomm20-denv. -defaults: - - override /target: mito_tomm20 - - override /predict_set: a549_mantis_tomm20_denv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch__tomm20_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_tomm20_fcmae_vscyto3d_scratch__tomm20_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index 2087a8dde..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Mitochondria (TOMM20) predicted by FCMAE_VSCyto3D_Scratch on a549-mantis-tomm20-mock. -defaults: - - override /target: mito_tomm20 - - override /predict_set: a549_mantis_tomm20_mock - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch__tomm20_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_tomm20_fcmae_vscyto3d_scratch__tomm20_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index 70b6ad214..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Mitochondria (TOMM20) predicted by FCMAE_VSCyto3D_Scratch on a549-mantis-tomm20-zikv. -defaults: - - override /target: mito_tomm20 - - override /predict_set: a549_mantis_tomm20_zikv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch__tomm20_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_tomm20_fcmae_vscyto3d_scratch__tomm20_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml index c77d7afc7..fa66e2346 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fcmae_vscyto3d_scratch/checkpoints/epoch=69-step=21840.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=69-step=21840.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch__tomm20_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20_ON_A549_tomm20_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..352d811ef --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_denv_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: mito__ipsc_confocal__fcmae_vscyto3d_scratch__a549_mantis_tomm20_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=69-step=21840.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20_ON_A549_tomm20_denv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml index d56fec22a..c46295e50 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fcmae_vscyto3d_scratch/checkpoints/epoch=69-step=21840.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=69-step=21840.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch__tomm20_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20_ON_A549_tomm20_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..363b25dc4 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_mock_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: mito__ipsc_confocal__fcmae_vscyto3d_scratch__a549_mantis_tomm20_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=69-step=21840.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20_ON_A549_tomm20_mock_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml index eb1867898..e07ef4642 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fcmae_vscyto3d_scratch/checkpoints/epoch=69-step=21840.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=69-step=21840.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch__tomm20_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20_ON_A549_tomm20_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..7816019f7 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_zikv_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: mito__ipsc_confocal__fcmae_vscyto3d_scratch__a549_mantis_tomm20_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=69-step=21840.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20_ON_A549_tomm20_zikv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml index f422eb471..0e920a6eb 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml @@ -21,7 +21,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fcmae_vscyto3d_scratch/checkpoints/epoch=69-step=21840.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=69-step=21840.ckpt data: init_args: @@ -38,8 +38,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_fcmae_vscyto3d_scratch.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20 - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..b4b287ed6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: mito__ipsc_confocal__fcmae_vscyto3d_scratch__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=69-step=21840.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fcmae_vscyto3d_scratch/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/train.yml index 5f53c3e9d..69ec357d5 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/ipsc_confocal/train.yml @@ -22,7 +22,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Scratch_iPSC_TOMM20 - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fcmae_vscyto3d_scratch + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_scratch callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -30,11 +30,13 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fcmae_vscyto3d_scratch/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_scratch/checkpoints launcher: job_name: FCMAE_VSCyto3D_Scratch_TOMM20 - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fcmae_vscyto3d_scratch + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fcmae_vscyto3d_scratch diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index 3e35ecc64..8fede39eb 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fcmae_vscyto3d_scratch/checkpoints/epoch=63-step=30720.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=84-step=40800-loss=0.534.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch_jointtrained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20_JOINTTR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index a13a27eb3..9a6a81143 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fcmae_vscyto3d_scratch/checkpoints/epoch=63-step=30720.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=84-step=40800-loss=0.534.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch_jointtrained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20_JOINTTR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index 89839646a..a2f2a64ee 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fcmae_vscyto3d_scratch/checkpoints/epoch=63-step=30720.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=84-step=40800-loss=0.534.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fcmae_vscyto3d_scratch_jointtrained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20_JOINTTR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index 14a65fd16..804a0f5b4 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fcmae_vscyto3d_scratch/checkpoints/epoch=63-step=30720.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto3d_scratch/checkpoints/epoch=84-step=40800-loss=0.534.ckpt data: init_args: @@ -40,8 +40,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_fcmae_vscyto3d_scratch_jointtrained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_TOMM20_JOINTTR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fcmae_vscyto3d_scratch/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/train.yml index 27bb8d0e3..05f58c139 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/train.yml @@ -17,7 +17,7 @@ base: - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_fit.yml - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu_long.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -34,7 +34,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Scratch_JOINT_TOMM20 - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fcmae_vscyto3d_scratch + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto3d_scratch callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -42,10 +42,12 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fcmae_vscyto3d_scratch/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto3d_scratch/checkpoints _hcs_init_args: &hcs_init_args source_channel: Phase3D @@ -135,8 +137,8 @@ data: - class_path: viscy_data.hcs.HCSDataModule init_args: <<: *hcs_init_args - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/TOMM20_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_JOINT_TOMM20 - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fcmae_vscyto3d_scratch + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fcmae_vscyto3d_scratch diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..97a175c33 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,52 @@ +# FNet2D predict: mito (TOMM20) trained on a549_mantis, tested on A549 mantis denv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=985-step=147900-loss=1.169.ckpt (loss/validate=1.169). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_denv + model_name: fnet2d + experiment_id: mito__a549_mantis__fnet2d__a549_mantis_tomm20_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fnet2d/checkpoints/epoch=985-step=147900-loss=1.169.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/a549__denv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_TOMM20_A549TR_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..8b4a000be --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,52 @@ +# FNet2D predict: mito (TOMM20) trained on a549_mantis, tested on A549 mantis mock. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=985-step=147900-loss=1.169.ckpt (loss/validate=1.169). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_mock + model_name: fnet2d + experiment_id: mito__a549_mantis__fnet2d__a549_mantis_tomm20_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fnet2d/checkpoints/epoch=985-step=147900-loss=1.169.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/a549__mock/prediction.zarr + +launcher: + job_name: FNet2D_PRED_TOMM20_A549TR_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..72403eeb3 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,52 @@ +# FNet2D predict: mito (TOMM20) trained on a549_mantis, tested on A549 mantis zikv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=985-step=147900-loss=1.169.ckpt (loss/validate=1.169). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_zikv + model_name: fnet2d + experiment_id: mito__a549_mantis__fnet2d__a549_mantis_tomm20_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fnet2d/checkpoints/epoch=985-step=147900-loss=1.169.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/a549__zikv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_TOMM20_A549TR_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..c7246a79e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,52 @@ +# FNet2D predict: mito (TOMM20) trained on a549_mantis, tested on iPSC confocal. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=985-step=147900-loss=1.169.ckpt (loss/validate=1.169). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: fnet2d + experiment_id: mito__a549_mantis__fnet2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fnet2d/checkpoints/epoch=985-step=147900-loss=1.169.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/ipsc/prediction.zarr + +launcher: + job_name: FNet2D_PRED_TOMM20_A549TR + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/train.yml new file mode 100644 index 000000000..7e597a83c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/a549_mantis/train.yml @@ -0,0 +1,56 @@ +# FNet2D (FNet3D run Z-preserving at Z=1) fit on mitochondria (TOMM20 marker) +# — A549 mantis-lightsheet pooled (mock + DENV + ZIKV), in-focus 2D track. +# Mirror of the 3D mito/fnet3d_paper/a549_mantis fit leaf, flattened onto the +# offline 5-plane in-focus slab store TOMM20_all_focus.zarr (z_window_size=1 +# emits one in-focus window per plane). target_channel == Structure, so the +# fnet2d data overlay's default norms/augs (already [1,64,64]) apply unchanged. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/data_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + train_set: a549_mantis + model_name: fnet2d + experiment_id: mito__a549_mantis__fnet2d + +trainer: + logger: + init_args: + name: FNet2D_A549_TOMM20 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fnet2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fnet2d/checkpoints + +data: + init_args: + # A549 pooled in-focus slab store + target_channel — no resolver in this + # train_set. + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all_focus.zarr + +launcher: + job_name: FNet2D_A549_TOMM20 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fnet2d + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D store + # (~1/4 the Z), so the 512G headroom the 3D leaf needed for mmap_preload + # is wasteful and delays scheduling. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..18fa8098d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,52 @@ +# FNet2D predict: mito (TOMM20) trained on ipsc_confocal, tested on A549 mantis denv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=567-step=189144-loss=1.631.ckpt (loss/validate=1.631). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_denv + model_name: fnet2d + experiment_id: mito__ipsc_confocal__fnet2d__a549_mantis_tomm20_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fnet2d/checkpoints/epoch=567-step=189144-loss=1.631.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_TOMM20_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..97ea0b4ee --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,52 @@ +# FNet2D predict: mito (TOMM20) trained on ipsc_confocal, tested on A549 mantis mock. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=567-step=189144-loss=1.631.ckpt (loss/validate=1.631). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_mock + model_name: fnet2d + experiment_id: mito__ipsc_confocal__fnet2d__a549_mantis_tomm20_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fnet2d/checkpoints/epoch=567-step=189144-loss=1.631.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: FNet2D_PRED_TOMM20_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..26423989d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,52 @@ +# FNet2D predict: mito (TOMM20) trained on ipsc_confocal, tested on A549 mantis zikv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=567-step=189144-loss=1.631.ckpt (loss/validate=1.631). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_zikv + model_name: fnet2d + experiment_id: mito__ipsc_confocal__fnet2d__a549_mantis_tomm20_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fnet2d/checkpoints/epoch=567-step=189144-loss=1.631.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_TOMM20_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..30ee3c61d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,52 @@ +# FNet2D predict: mito (TOMM20) trained on ipsc_confocal, tested on iPSC confocal. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=567-step=189144-loss=1.631.ckpt (loss/validate=1.631). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fnet2d + experiment_id: mito__ipsc_confocal__fnet2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fnet2d/checkpoints/epoch=567-step=189144-loss=1.631.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/ipsc/prediction.zarr + +launcher: + job_name: FNet2D_PRED_TOMM20 + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/train.yml new file mode 100644 index 000000000..5e94fc134 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/ipsc_confocal/train.yml @@ -0,0 +1,63 @@ +# FNet2D (FNet3D run Z-preserving at Z=1) fit on mitochondria (TOMM20 marker) +# — AICS iPSC confocal, in-focus 2D track. Mirror of the 3D +# mito/fnet3d_paper/ipsc_confocal fit leaf, flattened onto the offline 5-plane +# in-focus slab store TOMM20_focus.zarr (z_window_size=1 emits one in-focus +# window per plane). target_channel == Structure, so the fnet2d data overlay's +# default norms/augs (already [1,64,64]) apply unchanged. +# +# The 3D ipsc leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus +# TOMM20.zarr. The 2D track reads TOMM20_focus.zarr instead, so the resolver +# is disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field co-declared +# with a full dataset_ref. source_channel/target_channel reproduce the +# resolver's manifest output (Phase3D / Structure). +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/data_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + train_set: ipsc_confocal + model_name: fnet2d + experiment_id: mito__ipsc_confocal__fnet2d + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered TOMM20.zarr. dataset_ref: null makes + # the compose hook a no-op so data fields can be declared inline. + dataset_ref: null + +data: + init_args: + # iPSC in-focus slab store + channels — resolver disabled above. + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/TOMM20_focus.zarr + +trainer: + logger: + init_args: + name: FNet2D_iPSC_TOMM20 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fnet2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fnet2d/checkpoints + +launcher: + job_name: FNet2D_TOMM20 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fnet2d diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..02817d5b8 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,52 @@ +# FNet2D predict: mito (TOMM20) trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis denv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=385-step=186438-loss=1.417.ckpt (loss/validate=1.417). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_denv + model_name: fnet2d + experiment_id: mito__joint_ipsc_confocal_a549_mantis__fnet2d__a549_mantis_tomm20_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fnet2d/checkpoints/epoch=385-step=186438-loss=1.417.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/a549__denv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_TOMM20_JOINTTR_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..8e6ad3c8a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,52 @@ +# FNet2D predict: mito (TOMM20) trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis mock. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=385-step=186438-loss=1.417.ckpt (loss/validate=1.417). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_mock + model_name: fnet2d + experiment_id: mito__joint_ipsc_confocal_a549_mantis__fnet2d__a549_mantis_tomm20_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fnet2d/checkpoints/epoch=385-step=186438-loss=1.417.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/a549__mock/prediction.zarr + +launcher: + job_name: FNet2D_PRED_TOMM20_JOINTTR_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..b649a49ab --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,52 @@ +# FNet2D predict: mito (TOMM20) trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis zikv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=385-step=186438-loss=1.417.ckpt (loss/validate=1.417). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_zikv + model_name: fnet2d + experiment_id: mito__joint_ipsc_confocal_a549_mantis__fnet2d__a549_mantis_tomm20_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fnet2d/checkpoints/epoch=385-step=186438-loss=1.417.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/a549__zikv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_TOMM20_JOINTTR_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..de3bd0bbe --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,52 @@ +# FNet2D predict: mito (TOMM20) trained on joint_ipsc_confocal_a549_mantis, tested on iPSC confocal. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=385-step=186438-loss=1.417.ckpt (loss/validate=1.417). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: fnet2d + experiment_id: mito__joint_ipsc_confocal_a549_mantis__fnet2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fnet2d/checkpoints/epoch=385-step=186438-loss=1.417.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/ipsc/prediction.zarr + +launcher: + job_name: FNet2D_PRED_TOMM20_JOINTTR + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet2d/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..8ddbe5060 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet2d/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,123 @@ +# FNet2D (FNet3D run Z-preserving at Z=1) fit on mito (TOMM20) — joint +# ipsc_confocal + a549_mantis pooled, in-focus 2D track. Mirror of the 3D +# mito/fnet3d_paper/joint_* fit leaf, flattened onto the offline 5-plane +# in-focus slab stores (z_window_size=1 emits one in-focus window per plane). +# +# BatchedConcatDataModule + two explicit HCSDataModule children; only +# model_overlays/fnet2d_fit.yml is composed (the data block is authored +# inline here, not via data_overlays). Norms + 8-crops-per-FOV diverge from +# the CellDiff/UNetViT conventions: target channel uses mean/std (not +# median/iqr) and val augmentations are CPU CenterSpatialCropd on the raw +# keys. Crops flattened [32,64,64] -> [1,64,64], z_window_size 32 -> 1. +# +# Topology: single GPU, any model, long wall — same as the 3D FNet paper +# baseline, kept so iPSC-only and joint runs are apples-to-apples. +base: + - ../../../_internal/shared/model/model_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + gene: TOMM20 + target: mito + target_id: mito_tomm20 + train_set: joint_ipsc_confocal_a549_mantis + model_name: fnet2d + experiment_id: mito__joint_ipsc_confocal_a549_mantis__fnet2d + +trainer: + logger: + init_args: + name: FNet2D_JOINT_TOMM20 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fnet2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fnet2d/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Structure + z_window_size: 1 + # See nucleus/fnet2d/joint_*/train.yml for the rationale: joint mode does + # not divide batch_size by num_samples (unlike single-set), so + # 6 * num_samples=8 = 48 GPU samples matches single-set effective. + batch_size: 6 + num_workers: 8 + yx_patch_size: [64, 64] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Structure] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 64, 64] + num_samples: 8 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandFlipd + init_args: + keys: [source, target] + spatial_axes: [1] + prob: 0.5 + - class_path: viscy_transforms.BatchedRandFlipd + init_args: + keys: [source, target] + spatial_axes: [2] + prob: 0.5 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Phase3D, Structure] + roi_size: [1, 64, 64] + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc TOMM20 in-focus slab store + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/TOMM20_focus.zarr + # a549_mantis — pooled TOMM20 in-focus slab store + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all_focus.zarr + +launcher: + job_name: FNet2D_JOINT_TOMM20 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fnet2d + # 128G: the in-focus slab stores are 5-plane slices of the full-Z 3D + # stores (~1/4 the Z), so the 512G headroom the 3D joint leaf needed for + # dual mmap_preload is wasteful and delays scheduling. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml index 218578537..57336856b 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fnet3d_paper/checkpoints/epoch=248-step=126990.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fnet3d_paper/checkpoints/epoch=170-step=87210.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper_a549trained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/a549__denv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_TOMM20_A549TR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..abf810413 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_denv_lite + model_name: fnet3d_paper + experiment_id: mito__a549_mantis__fnet3d_paper__a549_mantis_tomm20_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fnet3d_paper/checkpoints/epoch=170-step=87210.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/a549/a549__denv/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_TOMM20_A549TR_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml index cc0c8b96c..b4a7f2712 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fnet3d_paper/checkpoints/epoch=248-step=126990.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fnet3d_paper/checkpoints/epoch=170-step=87210.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper_a549trained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/a549__mock/prediction.zarr launcher: job_name: FNet3DPaper_PRED_TOMM20_A549TR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..e8eebe042 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_mock_lite + model_name: fnet3d_paper + experiment_id: mito__a549_mantis__fnet3d_paper__a549_mantis_tomm20_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fnet3d_paper/checkpoints/epoch=170-step=87210.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/a549/a549__mock/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_TOMM20_A549TR_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml index 6313f1385..b46c22c27 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fnet3d_paper/checkpoints/epoch=248-step=126990.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fnet3d_paper/checkpoints/epoch=170-step=87210.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper_a549trained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/a549__zikv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_TOMM20_A549TR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..e732cbe9b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_zikv_lite + model_name: fnet3d_paper + experiment_id: mito__a549_mantis__fnet3d_paper__a549_mantis_tomm20_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fnet3d_paper/checkpoints/epoch=170-step=87210.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/a549/a549__zikv/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_TOMM20_A549TR_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml new file mode 100644 index 000000000..05c10c3dd --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml @@ -0,0 +1,48 @@ +# fnet3d_paper predict: mito trained on a549_mantis, +# predicting against the HEK293T third-cell-type probe (TOMM70A, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# mito/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'fnet3d_paper' (config dir 'fnet3d_paper'). +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_tomm70a_a549xy.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: hek_mantis_tomm70a_a549xy + model_name: fnet3d_paper + experiment_id: mito__a549_mantis__fnet3d_paper__hek_mantis_tomm70a_a549xy + dataset_ref: + target: tomm70a +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fnet3d_paper/checkpoints/epoch=170-step=87210.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/hek__a549xy/prediction.zarr +launcher: + job_name: FNET3D_PRED_MITO_A549TR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml index 727da6266..b4859e4b9 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fnet3d_paper/checkpoints/epoch=248-step=126990.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fnet3d_paper/checkpoints/epoch=170-step=87210.ckpt data: init_args: @@ -40,8 +40,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_fnet3d_paper_a549trained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/ipsc/prediction.zarr launcher: job_name: FNet3DPaper_PRED_TOMM20_A549TR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..74753d6ad --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: ipsc_confocal_lite + model_name: fnet3d_paper + experiment_id: mito__a549_mantis__fnet3d_paper__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fnet3d_paper/checkpoints/epoch=170-step=87210.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/a549/ipsc/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_TOMM20_A549TR_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/train.yml index 9750e6613..dac801268 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/a549_mantis/train.yml @@ -20,7 +20,7 @@ trainer: logger: init_args: name: FNet3D_A549_TOMM20_paper - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fnet3d_paper + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fnet3d_paper callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -28,20 +28,22 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fnet3d_paper/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fnet3d_paper/checkpoints data: init_args: # A549 pooled store + target_channel — no resolver in this train_set. target_channel: Structure - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/TOMM20_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all.zarr launcher: job_name: FNet3DPaper_A549_TOMM20 - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/tomm20/fnet3d_paper + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/fnet3d_paper # 512G to match the shared headroom convention across the fnet3d # leaves on a549/joint workloads. mmap_preload after the BasicIndexer # fix peaks at ~75 GB for TOMM20_all alone (single-set); 512G gives diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index 08dc34786..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Mitochondria (TOMM20) predicted by FNet3DPaper on a549-mantis-tomm20-denv. -defaults: - - override /target: mito_tomm20 - - override /predict_set: a549_mantis_tomm20_denv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper__tomm20_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_tomm20_fnet3d_paper__tomm20_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index 8ba1ca031..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Mitochondria (TOMM20) predicted by FNet3DPaper on a549-mantis-tomm20-mock. -defaults: - - override /target: mito_tomm20 - - override /predict_set: a549_mantis_tomm20_mock - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper__tomm20_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_tomm20_fnet3d_paper__tomm20_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index 5ef0baaf4..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Mitochondria (TOMM20) predicted by FNet3DPaper on a549-mantis-tomm20-zikv. -defaults: - - override /target: mito_tomm20 - - override /predict_set: a549_mantis_tomm20_zikv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper__tomm20_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_tomm20_fnet3d_paper__tomm20_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml index 4218a6e63..42c7dbd16 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml @@ -18,7 +18,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fnet3d_paper/checkpoints/epoch=215-step=187056.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fnet3d_paper/checkpoints/epoch=215-step=187056.ckpt data: init_args: @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper__tomm20_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/a549__denv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_TOMM20_ON_A549_tomm20_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..3e8056249 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_denv_lite + model_name: fnet3d_paper + experiment_id: mito__ipsc_confocal__fnet3d_paper__a549_mantis_tomm20_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fnet3d_paper/checkpoints/epoch=215-step=187056.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/ipsc/a549__denv/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_TOMM20_ON_A549_tomm20_denv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml index bb75c65b0..09021d632 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml @@ -18,7 +18,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fnet3d_paper/checkpoints/epoch=215-step=187056.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fnet3d_paper/checkpoints/epoch=215-step=187056.ckpt data: init_args: @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper__tomm20_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/a549__mock/prediction.zarr launcher: job_name: FNet3DPaper_PRED_TOMM20_ON_A549_tomm20_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..bdce48b61 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_mock_lite + model_name: fnet3d_paper + experiment_id: mito__ipsc_confocal__fnet3d_paper__a549_mantis_tomm20_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fnet3d_paper/checkpoints/epoch=215-step=187056.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/ipsc/a549__mock/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_TOMM20_ON_A549_tomm20_mock_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml index 461dec08f..d70092f7a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -18,7 +18,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fnet3d_paper/checkpoints/epoch=215-step=187056.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fnet3d_paper/checkpoints/epoch=215-step=187056.ckpt data: init_args: @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper__tomm20_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/a549__zikv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_TOMM20_ON_A549_tomm20_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..012cd93f0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_zikv_lite + model_name: fnet3d_paper + experiment_id: mito__ipsc_confocal__fnet3d_paper__a549_mantis_tomm20_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fnet3d_paper/checkpoints/epoch=215-step=187056.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_TOMM20_ON_A549_tomm20_zikv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__hek_mantis_tomm70a_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__hek_mantis_tomm70a_a549xy.yml new file mode 100644 index 000000000..9d4fb73c6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__hek_mantis_tomm70a_a549xy.yml @@ -0,0 +1,48 @@ +# fnet3d_paper predict: mito trained on ipsc_confocal, +# predicting against the HEK293T third-cell-type probe (TOMM70A, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# mito/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'fnet3d_paper' (config dir 'fnet3d_paper'). +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_tomm70a_a549xy.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: hek_mantis_tomm70a_a549xy + model_name: fnet3d_paper + experiment_id: mito__ipsc_confocal__fnet3d_paper__hek_mantis_tomm70a_a549xy + dataset_ref: + target: tomm70a +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fnet3d_paper/checkpoints/epoch=215-step=187056.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/hek__a549xy/prediction.zarr +launcher: + job_name: FNET3D_PRED_MITO_IPSCTR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml index 4db0561c6..e9ede0c97 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml @@ -18,7 +18,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fnet3d_paper/checkpoints/epoch=215-step=187056.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fnet3d_paper/checkpoints/epoch=215-step=187056.ckpt data: init_args: @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_fnet3d_paper.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/ipsc/prediction.zarr launcher: job_name: FNet3DPaper_PRED_TOMM20 - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..f25ef20a9 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: fnet3d_paper + experiment_id: mito__ipsc_confocal__fnet3d_paper__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fnet3d_paper/checkpoints/epoch=215-step=187056.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/ipsc/ipsc/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_TOMM20_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/fnet3d_paper/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/train.yml index db67cfe4c..cafbe1569 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/ipsc_confocal/train.yml @@ -20,7 +20,7 @@ trainer: logger: init_args: name: FNet3D_iPSC_TOMM20_paper - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fnet3d_paper + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fnet3d_paper callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -28,11 +28,13 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fnet3d_paper/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fnet3d_paper/checkpoints launcher: job_name: FNet3DPaper_TOMM20 - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/tomm20/fnet3d_paper + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/fnet3d_paper diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index 88bf835b9..e79e8cfaf 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fnet3d_paper/checkpoints/epoch=132-step=183008.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fnet3d_paper/checkpoints/epoch=139-step=192640.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper_jointtrained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/a549__denv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_TOMM20_JOINTTR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index 043456898..4339a54c3 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fnet3d_paper/checkpoints/epoch=132-step=183008.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fnet3d_paper/checkpoints/epoch=139-step=192640.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper_jointtrained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/a549__mock/prediction.zarr launcher: job_name: FNet3DPaper_PRED_TOMM20_JOINTTR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index 6bd1ed5b1..e292f6ea6 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -22,7 +22,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fnet3d_paper/checkpoints/epoch=132-step=183008.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fnet3d_paper/checkpoints/epoch=139-step=192640.ckpt data: init_args: @@ -39,8 +39,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_fnet3d_paper_jointtrained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/a549__zikv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_TOMM20_JOINTTR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml new file mode 100644 index 000000000..bde0cc6c6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml @@ -0,0 +1,48 @@ +# fnet3d_paper predict: mito trained on joint_ipsc_confocal_a549_mantis, +# predicting against the HEK293T third-cell-type probe (TOMM70A, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'fnet3d_paper' (config dir 'fnet3d_paper'). +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_tomm70a_a549xy.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: hek_mantis_tomm70a_a549xy + model_name: fnet3d_paper + experiment_id: mito__joint_ipsc_confocal_a549_mantis__fnet3d_paper__hek_mantis_tomm70a_a549xy + dataset_ref: + target: tomm70a +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fnet3d_paper/checkpoints/epoch=139-step=192640.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/hek__a549xy/prediction.zarr +launcher: + job_name: FNET3D_PRED_MITO_JOINTTR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index 8a7c911ff..19650e5c8 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fnet3d_paper/checkpoints/epoch=132-step=183008.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fnet3d_paper/checkpoints/epoch=139-step=192640.ckpt data: init_args: @@ -40,8 +40,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_fnet3d_paper_jointtrained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/ipsc/prediction.zarr launcher: job_name: FNet3DPaper_PRED_TOMM20_JOINTTR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/fnet3d_paper/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/train.yml index a4fa68f83..254045ccd 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/fnet3d_paper/joint_ipsc_confocal_a549_mantis/train.yml @@ -34,7 +34,7 @@ trainer: logger: init_args: name: FNet3D_JOINT_TOMM20_paper - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fnet3d_paper + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fnet3d_paper callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -42,10 +42,12 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fnet3d_paper/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fnet3d_paper/checkpoints _hcs_init_args: &hcs_init_args source_channel: Phase3D @@ -111,11 +113,11 @@ data: - class_path: viscy_data.hcs.HCSDataModule init_args: <<: *hcs_init_args - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/TOMM20_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all.zarr launcher: job_name: FNet3DPaper_JOINT_TOMM20 - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/fnet3d_paper + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/fnet3d_paper # Joint preloads two stores (iPSC + A549 pool) into /dev/shm; the default # 256G cap is too tight (256G iPSC mem + ~50G A549 + worker peak OOMs). # 512G is the smallest tier that fits joint preload + worker overhead. diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..9d436d930 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: mito trained on a549_mantis, tested on A549 mantis denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/mito_tomm20.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_denv + model_name: pix2pix2d_unetvit + experiment_id: mito__a549_mantis__pix2pix2d_unetvit__a549_mantis_tomm20_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix2d_unetvit/checkpoints/epoch=32-step=7194-loss=1.184.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/a549__denv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_A549_TOMM20_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..446d7d723 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: mito trained on a549_mantis, tested on A549 mantis mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/mito_tomm20.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_mock + model_name: pix2pix2d_unetvit + experiment_id: mito__a549_mantis__pix2pix2d_unetvit__a549_mantis_tomm20_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix2d_unetvit/checkpoints/epoch=32-step=7194-loss=1.184.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/a549__mock/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_A549_TOMM20_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..a3eb18bc6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: mito trained on a549_mantis, tested on A549 mantis zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/mito_tomm20.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_zikv + model_name: pix2pix2d_unetvit + experiment_id: mito__a549_mantis__pix2pix2d_unetvit__a549_mantis_tomm20_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix2d_unetvit/checkpoints/epoch=32-step=7194-loss=1.184.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/a549__zikv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_A549_TOMM20_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..6e3ae4fb4 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: mito trained on a549_mantis, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/mito_tomm20.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit + experiment_id: mito__a549_mantis__pix2pix2d_unetvit__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix2d_unetvit/checkpoints/epoch=32-step=7194-loss=1.184.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/ipsc/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_A549_TOMM20_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/train.yml new file mode 100644 index 000000000..655d3450f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/a549_mantis/train.yml @@ -0,0 +1,102 @@ +# pix2pix2d_unetvit (UNetViT generator + multi-scale PatchGAN, run +# Z-preserving at Z=1) fit on mito (Structure channel) — A549 mantis-lightsheet pooled (mock + DENV + ZIKV), +# in-focus 2D track. Mirror of the 3D +# mito/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml leaf, +# flattened onto the offline 5-plane in-focus slab store (z_window_size=1 +# emits one in-focus window per plane). +# +# ⚠ Mirrors train_4gpu_modernized.yml, NOT the stale sibling train.yml. The +# published pix2pix3d rows came from the modernized "Run D" recipe — the +# checkpoints carry loss_type='nonsat', lr 2e-4/2e-4, r1_gamma=10, +# ema_kimg=10, lecam_gamma=0.3, lambda_l1=10 and 201 generator_ema.* tensors +# — while train.yml still composes the LSGAN baseline overlay. All of Run D is +# baked into model_overlays/pix2pix2d_unetvit_fit.yml, so unlike the 3D leaves +# this file repeats none of it. +# +# The 3D leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus store. +# The 2D track reads the `_focus.zarr` slab instead, so the resolver is +# disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field co-declared +# with a full dataset_ref. +# +# The train_set fragment supplies data.class_path (HCSDataModule) plus +# split_ratio / mmap_preload / scratch_dir. targets/mito_tomm20.yml supplies the +# NormalizeSampled(fov_statistics) normalization the pix2pix leaves use +# (mean/std on Phase3D, median/iqr on the target); only its RandWeightedCropd +# is list-replaced below, flattened [13,624,624] -> [1,624,624]. + +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + gene: TOMM20 + target: mito + target_id: mito + train_set: a549_mantis + model_name: pix2pix2d_unetvit + experiment_id: mito__a549_mantis__pix2pix2d_unetvit + # Disable the manifest resolver: the 2D track reads the offline focus store, + # not the manifest-registered non-focus store. + dataset_ref: null + +data: + init_args: + # pooled A549 in-focus slab store (Structure channel) — resolver disabled above. + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all_focus.zarr + # Flatten the target fragment's [13, 624, 624] weighted crop to Z=1. + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 624, 624] + num_samples: 2 + +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_A549_TOMM20 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix2d_unetvit + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + # monitor loss/validate_ema, matching the 3D Run-D leaves: ema_kimg is set, + # so the EMA generator is the one the recipe selects on and the one predict + # reports. Monitoring the raw loss/validate would pin a different epoch. + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix2d_unetvit/checkpoints + +launcher: + job_name: pix2pix2d_unetvit_A549_TOMM20 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix2d_unetvit + sbatch: + # Narrow OFF the hardware_4gpu h100|h200 default, the opposite of the 3D + # leaf. 3D needed h200 because the GAN OOMs 80 GB at Z=8; measured at Z=1 + # on an A40 (44.7 GiB) peak is 13.3 GiB/rank at batch_size 4, so the 48 GB + # cards have 3x headroom and reserving Hopper for this would be queue + # squatting. The profile documents this opt-out explicitly. + constraint: "a40|a6000|l40s|h100|h200" + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D store + # (~1/4 the Z), so the profile's 512G mmap_preload headroom is inherited 3D + # scale. Set in the LEAF BODY because launcher_profiles compose after model + # overlays and would otherwise win. + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..0ea493724 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: mito trained on ipsc_confocal, tested on A549 mantis denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/mito_tomm20.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_denv + model_name: pix2pix2d_unetvit + experiment_id: mito__ipsc_confocal__pix2pix2d_unetvit__a549_mantis_tomm20_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix2d_unetvit/checkpoints/epoch=19-step=10000-loss=1.033.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_TOMM20_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..7a24ad157 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: mito trained on ipsc_confocal, tested on A549 mantis mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/mito_tomm20.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_mock + model_name: pix2pix2d_unetvit + experiment_id: mito__ipsc_confocal__pix2pix2d_unetvit__a549_mantis_tomm20_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix2d_unetvit/checkpoints/epoch=19-step=10000-loss=1.033.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_TOMM20_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..53b51febb --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: mito trained on ipsc_confocal, tested on A549 mantis zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/mito_tomm20.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_zikv + model_name: pix2pix2d_unetvit + experiment_id: mito__ipsc_confocal__pix2pix2d_unetvit__a549_mantis_tomm20_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix2d_unetvit/checkpoints/epoch=19-step=10000-loss=1.033.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_TOMM20_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..e8331c482 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: mito trained on ipsc_confocal, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/mito_tomm20.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit + experiment_id: mito__ipsc_confocal__pix2pix2d_unetvit__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix2d_unetvit/checkpoints/epoch=19-step=10000-loss=1.033.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/ipsc/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_TOMM20_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/train.yml new file mode 100644 index 000000000..5fc0151e3 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/ipsc_confocal/train.yml @@ -0,0 +1,102 @@ +# pix2pix2d_unetvit (UNetViT generator + multi-scale PatchGAN, run +# Z-preserving at Z=1) fit on mito (Structure channel) — AICS iPSC confocal, +# in-focus 2D track. Mirror of the 3D +# mito/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml leaf, +# flattened onto the offline 5-plane in-focus slab store (z_window_size=1 +# emits one in-focus window per plane). +# +# ⚠ Mirrors train_4gpu_modernized.yml, NOT the stale sibling train.yml. The +# published pix2pix3d rows came from the modernized "Run D" recipe — the +# checkpoints carry loss_type='nonsat', lr 2e-4/2e-4, r1_gamma=10, +# ema_kimg=10, lecam_gamma=0.3, lambda_l1=10 and 201 generator_ema.* tensors +# — while train.yml still composes the LSGAN baseline overlay. All of Run D is +# baked into model_overlays/pix2pix2d_unetvit_fit.yml, so unlike the 3D leaves +# this file repeats none of it. +# +# The 3D leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus store. +# The 2D track reads the `_focus.zarr` slab instead, so the resolver is +# disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field co-declared +# with a full dataset_ref. +# +# The train_set fragment supplies data.class_path (HCSDataModule) plus +# split_ratio / mmap_preload / scratch_dir. targets/mito_tomm20.yml supplies the +# NormalizeSampled(fov_statistics) normalization the pix2pix leaves use +# (mean/std on Phase3D, median/iqr on the target); only its RandWeightedCropd +# is list-replaced below, flattened [13,624,624] -> [1,624,624]. + +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + gene: TOMM20 + target: mito + target_id: mito + train_set: ipsc_confocal + model_name: pix2pix2d_unetvit + experiment_id: mito__ipsc_confocal__pix2pix2d_unetvit + # Disable the manifest resolver: the 2D track reads the offline focus store, + # not the manifest-registered non-focus store. + dataset_ref: null + +data: + init_args: + # aics-hipsc in-focus slab store (Structure channel) — resolver disabled above. + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/TOMM20_focus.zarr + # Flatten the target fragment's [13, 624, 624] weighted crop to Z=1. + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 624, 624] + num_samples: 2 + +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_iPSC_TOMM20 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix2d_unetvit + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + # monitor loss/validate_ema, matching the 3D Run-D leaves: ema_kimg is set, + # so the EMA generator is the one the recipe selects on and the one predict + # reports. Monitoring the raw loss/validate would pin a different epoch. + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix2d_unetvit/checkpoints + +launcher: + job_name: pix2pix2d_unetvit_iPSC_TOMM20 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix2d_unetvit + sbatch: + # Narrow OFF the hardware_4gpu h100|h200 default, the opposite of the 3D + # leaf. 3D needed h200 because the GAN OOMs 80 GB at Z=8; measured at Z=1 + # on an A40 (44.7 GiB) peak is 13.3 GiB/rank at batch_size 4, so the 48 GB + # cards have 3x headroom and reserving Hopper for this would be queue + # squatting. The profile documents this opt-out explicitly. + constraint: "a40|a6000|l40s|h100|h200" + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D store + # (~1/4 the Z), so the profile's 512G mmap_preload headroom is inherited 3D + # scale. Set in the LEAF BODY because launcher_profiles compose after model + # overlays and would otherwise win. + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..2ca1cc63e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: mito trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/mito_tomm20.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_denv + model_name: pix2pix2d_unetvit + experiment_id: mito__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit__a549_mantis_tomm20_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix2d_unetvit/checkpoints/epoch=20-step=15372-loss=1.061.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/a549__denv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_JOINT_TOMM20_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..5c5edbb41 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: mito trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/mito_tomm20.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_mock + model_name: pix2pix2d_unetvit + experiment_id: mito__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit__a549_mantis_tomm20_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix2d_unetvit/checkpoints/epoch=20-step=15372-loss=1.061.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/a549__mock/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_JOINT_TOMM20_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..43ecd7856 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: mito trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/mito_tomm20.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_zikv + model_name: pix2pix2d_unetvit + experiment_id: mito__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit__a549_mantis_tomm20_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix2d_unetvit/checkpoints/epoch=20-step=15372-loss=1.061.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/a549__zikv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_JOINT_TOMM20_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..4192e6349 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: mito trained on joint_ipsc_confocal_a549_mantis, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/mito_tomm20.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit + experiment_id: mito__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix2d_unetvit/checkpoints/epoch=20-step=15372-loss=1.061.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/ipsc/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_JOINT_TOMM20_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..e082918b0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,170 @@ +# pix2pix2d_unetvit (UNetViT generator + multi-scale PatchGAN, run +# Z-preserving at Z=1) fit on mito (Structure channel) — joint ipsc_confocal + a549_mantis pooled, +# in-focus 2D track. Mirror of the 3D +# mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml leaf, +# flattened onto the offline 5-plane in-focus slab store (z_window_size=1 +# emits one in-focus window per plane). +# +# ⚠ Mirrors train_4gpu_modernized.yml, NOT the stale sibling train.yml. The +# published pix2pix3d rows came from the modernized "Run D" recipe — the +# checkpoints carry loss_type='nonsat', lr 2e-4/2e-4, r1_gamma=10, +# ema_kimg=10, lecam_gamma=0.3, lambda_l1=10 and 201 generator_ema.* tensors +# — while train.yml still composes the LSGAN baseline overlay. All of Run D is +# baked into model_overlays/pix2pix2d_unetvit_fit.yml, so unlike the 3D leaves +# this file repeats none of it. +# +# BatchedConcatDataModule + two explicit HCSDataModule children; only +# model_overlays/pix2pix2d_unetvit_fit.yml is composed (the data block is +# authored inline here, not via data_overlays). +# +# Normalization is NormalizeSampled (fov_statistics), matching the single-set +# pix2pix2d leaves — divergent from the celldiff joint, which uses +# MinMaxSampled. Per-organelle prior is to keep joint and single-set +# normalizations identical so ablations are apples-to-apples. +# +# batch_size 2 here, NOT the single-set 4: BatchedConcatDataModule's +# train_dataloader uses batch_size as-is, while HCSDataModule divides by +# RandWeightedCropd num_samples. 2 indices * 2 num_samples = 4 GPU samples per +# rank, x 4 DDP ranks = the same 16 samples/step as the 3D arm. +base: + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + gene: TOMM20 + target: mito + target_id: mito + train_set: joint_ipsc_confocal_a549_mantis + model_name: pix2pix2d_unetvit + experiment_id: mito__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit + +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_JOINT_TOMM20 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix2d_unetvit + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + # monitor loss/validate_ema, matching the 3D Run-D leaves: ema_kimg is set, + # so the EMA generator is the one the recipe selects on and the one predict + # reports. Monitoring the raw loss/validate would pin a different epoch. + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix2d_unetvit/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Structure + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: [512, 512] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Structure] + level: fov_statistics + subtrahend: median + divisor: iqr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [1, 624, 624] + num_samples: 2 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [0, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[1, 1], [0.5, 1.5], [0.5, 1.5]] + safe_crop_size: [1, 512, 512] + safe_crop_coverage: 0.9 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0, 0] + val_gpu_augmentations: + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc in-focus slab store (Structure channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/TOMM20_focus.zarr + # a549_mantis — pooled A549 in-focus slab store (Structure channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all_focus.zarr + +launcher: + job_name: pix2pix2d_unetvit_JOINT_TOMM20 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix2d_unetvit + sbatch: + # Narrow OFF the hardware_4gpu h100|h200 default, the opposite of the 3D + # leaf. 3D needed h200 because the GAN OOMs 80 GB at Z=8; measured at Z=1 + # on an A40 (44.7 GiB) peak is 13.3 GiB/rank at batch_size 4, so the 48 GB + # cards have 3x headroom and reserving Hopper for this would be queue + # squatting. The profile documents this opt-out explicitly. + constraint: "a40|a6000|l40s|h100|h200" + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D store + # (~1/4 the Z), so the profile's 512G mmap_preload headroom is inherited 3D + # scale. Set in the LEAF BODY because launcher_profiles compose after model + # overlays and would otherwise win. + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..576d61e2b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of mito/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_denv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: mito__a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_tomm20_denv +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix2d_unetvit_wmatch/checkpoints/epoch=39-step=8720-loss=1.155.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/a549/a549__denv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_A549_TOMM20_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..3b9710d70 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of mito/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_mock + model_name: pix2pix2d_unetvit_wmatch + experiment_id: mito__a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_tomm20_mock +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix2d_unetvit_wmatch/checkpoints/epoch=39-step=8720-loss=1.155.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/a549/a549__mock/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_A549_TOMM20_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..e3fc0e119 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of mito/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_zikv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: mito__a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_tomm20_zikv +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix2d_unetvit_wmatch/checkpoints/epoch=39-step=8720-loss=1.155.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/a549/a549__zikv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_A549_TOMM20_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..dd8a7bad2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of mito/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch + experiment_id: mito__a549_mantis__pix2pix2d_unetvit_wmatch__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix2d_unetvit_wmatch/checkpoints/epoch=39-step=8720-loss=1.155.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/a549/ipsc/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_A549_TOMM20_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/train.yml new file mode 100644 index 000000000..439e1c770 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/a549_mantis/train.yml @@ -0,0 +1,69 @@ +# pix2pix2d `wmatch` arm (fit) of mito/pix2pix2d_unetvit/a549_mantis/train.yml. +# Recipe delta: warmup_steps 8500 -> 1177. Run-D's 8500-batch warmup is +# 27.0 % of the matching 3D fit (31480 batches); this 2D fit runs 4360, so +# round(8500 * 4360 / 31480) keeps the same schedule shape. The baseline's absolute 8500 +# left 5 of 12 2D fits still warming up at their last step (wandb lr-AdamW, 2026-10-22). +# Everything else, and the rationale for it, is the baseline leaf's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_fit_leaves.py. +base: +- ../../../_internal/shared/model/train_sets/a549_mantis.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + gene: TOMM20 + target: mito + target_id: mito + train_set: a549_mantis + model_name: pix2pix2d_unetvit_wmatch + experiment_id: mito__a549_mantis__pix2pix2d_unetvit_wmatch + dataset_ref: null +data: + init_args: + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Structure + w_key: Structure + spatial_size: + - 1 + - 624 + - 624 + num_samples: 2 +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_wmatch_A549_TOMM20 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix2d_unetvit_wmatch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: epoch={epoch}-step={step}-loss={loss/validate_ema:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix2d_unetvit_wmatch/checkpoints +launcher: + job_name: pix2pix2d_unetvit_wmatch_A549_TOMM20 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix2d_unetvit_wmatch + sbatch: + constraint: a40|a6000|l40s|h100|h200 + mem: 128G +model: + init_args: + warmup_steps: 1177 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..1bbe3a7ee --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of mito/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_denv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: mito__ipsc_confocal__pix2pix2d_unetvit_wmatch__a549_mantis_tomm20_denv +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix2d_unetvit_wmatch/checkpoints/epoch=18-step=9500-loss=1.031.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/ipsc/a549__denv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_TOMM20_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..854e70818 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of mito/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_mock + model_name: pix2pix2d_unetvit_wmatch + experiment_id: mito__ipsc_confocal__pix2pix2d_unetvit_wmatch__a549_mantis_tomm20_mock +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix2d_unetvit_wmatch/checkpoints/epoch=18-step=9500-loss=1.031.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/ipsc/a549__mock/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_TOMM20_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..0016ecbcb --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of mito/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_zikv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: mito__ipsc_confocal__pix2pix2d_unetvit_wmatch__a549_mantis_tomm20_zikv +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix2d_unetvit_wmatch/checkpoints/epoch=18-step=9500-loss=1.031.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_TOMM20_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..c3d32dd5c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of mito/pix2pix2d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch + experiment_id: mito__ipsc_confocal__pix2pix2d_unetvit_wmatch__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix2d_unetvit_wmatch/checkpoints/epoch=18-step=9500-loss=1.031.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/ipsc/ipsc/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_TOMM20_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/train.yml new file mode 100644 index 000000000..9b2c07c15 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/ipsc_confocal/train.yml @@ -0,0 +1,69 @@ +# pix2pix2d `wmatch` arm (fit) of mito/pix2pix2d_unetvit/ipsc_confocal/train.yml. +# Recipe delta: warmup_steps 8500 -> 1328. Run-D's 8500-batch warmup is +# 13.3 % of the matching 3D fit (64000 batches); this 2D fit runs 10000, so +# round(8500 * 10000 / 64000) keeps the same schedule shape. The baseline's absolute 8500 +# left 5 of 12 2D fits still warming up at their last step (wandb lr-AdamW, 2026-10-22). +# Everything else, and the rationale for it, is the baseline leaf's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_fit_leaves.py. +base: +- ../../../_internal/shared/model/train_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + gene: TOMM20 + target: mito + target_id: mito + train_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch + experiment_id: mito__ipsc_confocal__pix2pix2d_unetvit_wmatch + dataset_ref: null +data: + init_args: + source_channel: Phase3D + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/TOMM20_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Structure + w_key: Structure + spatial_size: + - 1 + - 624 + - 624 + num_samples: 2 +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_wmatch_iPSC_TOMM20 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix2d_unetvit_wmatch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: epoch={epoch}-step={step}-loss={loss/validate_ema:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix2d_unetvit_wmatch/checkpoints +launcher: + job_name: pix2pix2d_unetvit_wmatch_iPSC_TOMM20 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix2d_unetvit_wmatch + sbatch: + constraint: a40|a6000|l40s|h100|h200 + mem: 128G +model: + init_args: + warmup_steps: 1328 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..9cde8128c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_denv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: mito__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_tomm20_denv +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix2d_unetvit_wmatch/checkpoints/epoch=23-step=17568-loss=1.048.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/joint/a549__denv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_JOINT_TOMM20_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..8cb8aef51 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_mock + model_name: pix2pix2d_unetvit_wmatch + experiment_id: mito__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_tomm20_mock +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix2d_unetvit_wmatch/checkpoints/epoch=23-step=17568-loss=1.048.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/joint/a549__mock/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_JOINT_TOMM20_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..1b4241d4d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_zikv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: mito__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_tomm20_zikv +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix2d_unetvit_wmatch/checkpoints/epoch=23-step=17568-loss=1.048.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/joint/a549__zikv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_JOINT_TOMM20_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..14e55524c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch + experiment_id: mito__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix2d_unetvit_wmatch/checkpoints/epoch=23-step=17568-loss=1.048.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/mito/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/joint/ipsc/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_JOINT_TOMM20_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix2d_unetvit_wmatch/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..d17022788 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,207 @@ +# pix2pix2d `wmatch` arm (fit) of mito/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml. +# Recipe delta: warmup_steps 8500 -> 1279. Run-D's 8500-batch warmup is +# 8.7 % of the matching 3D fit (97280 batches); this 2D fit runs 14640, so +# round(8500 * 14640 / 97280) keeps the same schedule shape. The baseline's absolute 8500 +# left 5 of 12 2D fits still warming up at their last step (wandb lr-AdamW, 2026-10-22). +# Everything else, and the rationale for it, is the baseline leaf's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_fit_leaves.py. +base: +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + gene: TOMM20 + target: mito + target_id: mito + train_set: joint_ipsc_confocal_a549_mantis + model_name: pix2pix2d_unetvit_wmatch + experiment_id: mito__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_wmatch_JOINT_TOMM20 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix2d_unetvit_wmatch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: epoch={epoch}-step={step}-loss={loss/validate_ema:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix2d_unetvit_wmatch/checkpoints +_hcs_init_args: + source_channel: Phase3D + target_channel: Structure + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: &id001 + - 512 + - 512 + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: &id002 + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Structure + level: fov_statistics + subtrahend: median + divisor: iqr + augmentations: &id003 + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Structure + w_key: Structure + spatial_size: + - 1 + - 624 + - 624 + num_samples: 2 + gpu_augmentations: &id004 + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: + - source + - target + prob: 0.8 + rotate_range: + - 0 + - 0 + - 0 + shear_range: + - 0.0 + - 0.05 + - 0.05 + scale_range: + - - 1 + - 1 + - - 0.5 + - 1.5 + - - 0.5 + - 1.5 + safe_crop_size: + - 1 + - 512 + - 512 + safe_crop_coverage: 0.9 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: + - source + - target + roi_size: + - 1 + - 512 + - 512 + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: + - source + prob: 0.5 + gamma: + - 0.8 + - 1.2 + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: + - source + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: + - source + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: + - source + prob: 0.5 + sigma_x: + - 0.25 + - 0.75 + sigma_y: + - 0.25 + - 0.75 + sigma_z: + - 0 + - 0 + val_gpu_augmentations: &id005 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: + - source + - target + roi_size: + - 1 + - 512 + - 512 +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + - class_path: viscy_data.hcs.HCSDataModule + init_args: + source_channel: Phase3D + target_channel: Structure + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: *id001 + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: *id002 + augmentations: *id003 + gpu_augmentations: *id004 + val_gpu_augmentations: *id005 + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/TOMM20_focus.zarr + - class_path: viscy_data.hcs.HCSDataModule + init_args: + source_channel: Phase3D + target_channel: Structure + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: *id001 + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: *id002 + augmentations: *id003 + gpu_augmentations: *id004 + val_gpu_augmentations: *id005 + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all_focus.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_JOINT_TOMM20 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix2d_unetvit_wmatch + sbatch: + constraint: a40|a6000|l40s|h100|h200 + mem: 128G +model: + init_args: + warmup_steps: 1279 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..efb776a22 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,48 @@ +# pix2pix3d_unetvit predict: mito (TOMM20) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/pix2pix3d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_denv + model_name: pix2pix3d_unetvit + experiment_id: mito__a549_mantis__pix2pix3d_unetvit__a549_mantis_tomm20_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix3d_unetvit/checkpoints/epoch=27-step=44072.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__denv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center + +launcher: + job_name: pix2pix3d_unetvit_PRED_TOMM20_A549TR_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..4174726fc --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,48 @@ +# pix2pix3d_unetvit predict: mito (TOMM20) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/pix2pix3d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_mock + model_name: pix2pix3d_unetvit + experiment_id: mito__a549_mantis__pix2pix3d_unetvit__a549_mantis_tomm20_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix3d_unetvit/checkpoints/epoch=27-step=44072.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__mock/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center + +launcher: + job_name: pix2pix3d_unetvit_PRED_TOMM20_A549TR_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..f1d410320 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,48 @@ +# pix2pix3d_unetvit predict: mito (TOMM20) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/pix2pix3d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_zikv + model_name: pix2pix3d_unetvit + experiment_id: mito__a549_mantis__pix2pix3d_unetvit__a549_mantis_tomm20_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix3d_unetvit/checkpoints/epoch=27-step=44072.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__zikv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center + +launcher: + job_name: pix2pix3d_unetvit_PRED_TOMM20_A549TR_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml new file mode 100644 index 000000000..32e193555 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml @@ -0,0 +1,49 @@ +# pix2pix3d_unetvit predict: mito trained on a549_mantis, +# predicting against the HEK293T third-cell-type probe (TOMM70A, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# mito/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'pix2pix3d_unetvit' (config dir 'pix2pix3d_unetvit'). +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_tomm70a_a549xy.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/pix2pix3d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: hek_mantis_tomm70a_a549xy + model_name: pix2pix3d_unetvit + experiment_id: mito__a549_mantis__pix2pix3d_unetvit__hek_mantis_tomm70a_a549xy + dataset_ref: + target: tomm70a +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix3d_unetvit/checkpoints/epoch=27-step=44072.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/hek__a549xy/prediction.zarr + z_reduction: center +launcher: + job_name: PIX2PIX3D_PRED_MITO_A549TR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..1ffe825d3 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,48 @@ +# pix2pix3d_unetvit predict: mito (TOMM20) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/pix2pix3d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: pix2pix3d_unetvit + experiment_id: mito__a549_mantis__pix2pix3d_unetvit__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix3d_unetvit/checkpoints/epoch=27-step=44072.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/ipsc/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center + +launcher: + job_name: pix2pix3d_unetvit_PRED_TOMM20_A549TR_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/train.yml index 661cdf2f9..4d0d6eb97 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/train.yml @@ -27,6 +27,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml new file mode 100644 index 000000000..011a844a6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml @@ -0,0 +1,59 @@ +# pix2pix3d_unetvit MODERNIZED fit on mito (Structure channel of TOMM20 store) — A549 mantis-lightsheet pooled (mock + DENV + ZIKV), 4-GPU DDP. +# +# Finalized "Run D" recipe: modernized overlay (nonsat + R1 + G-EMA, equal LR) +# + lambda_l1=10 + LeCam gamma=0.3 + 40 epochs. Mirrors the completed nucleus +# modernized runs (same recipe, Structure channel / TOMM20 store). Submit with NO overrides. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/data_overlays/unetvit3d_fit.yml + - ../../../_internal/shared/model/model_overlays/pix2pix3d_unetvit_fit_ddp_modernized.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + train_set: a549_mantis + model_name: pix2pix3d_unetvit + experiment_id: mito__a549_mantis__pix2pix3d_unetvit_modernized + +model: + init_args: + lambda_l1: 10.0 + lecam_gamma: 0.3 + +trainer: + max_epochs: 40 + logger: + init_args: + name: pix2pix3d_unetvit_A549_TOMM20_4gpu_modernized_lambdaL1_10_lecam_40ep + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix3d_unetvit + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix3d_unetvit/checkpoints + +data: + init_args: + # A549 pooled store + target_channel — no resolver in this train_set. + target_channel: Structure + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all.zarr + +launcher: + job_name: pix2pix3d_unetvit_A549_TOMM20_4gpu_modernized_lambdaL1_10_lecam_40ep + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/pix2pix3d_unetvit + # pix2pix3d GAN (UNetViT3D G + multiscale-patch D, large 3D crops) OOMs on + # 80 GB h100; needs h200 (141 GB). Narrow the hardware_4gpu h100|h200 default. + sbatch: + constraint: h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index 4621fe2d7..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: mito (TOMM20) predicted by pix2pix3d_unetvit on a549-mantis-tomm20-denv. -defaults: - - override /target: mito_tomm20 - - override /predict_set: a549_mantis_tomm20_denv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_pix2pix3d_unetvit__tomm20_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_tomm20_pix2pix3d_unetvit__tomm20_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index fb0964aef..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: mito (TOMM20) predicted by pix2pix3d_unetvit on a549-mantis-tomm20-mock. -defaults: - - override /target: mito_tomm20 - - override /predict_set: a549_mantis_tomm20_mock - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_pix2pix3d_unetvit__tomm20_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_tomm20_pix2pix3d_unetvit__tomm20_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index 860f303e8..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: mito (TOMM20) predicted by pix2pix3d_unetvit on a549-mantis-tomm20-zikv. -defaults: - - override /target: mito_tomm20 - - override /predict_set: a549_mantis_tomm20_zikv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_pix2pix3d_unetvit__tomm20_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_tomm20_pix2pix3d_unetvit__tomm20_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 100644 index 75b74a339..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: mito (TOMM20) predicted by pix2pix3d_unetvit on iPSC confocal. -defaults: - - override /target: mito_tomm20 - - override /predict_set: ipsc_confocal - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_pix2pix3d_unetvit.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/eval_tomm20_pix2pix3d_unetvit diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml index 0fa6d45bb..a06e4dd91 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: REPLACE_ME_WITH_PRODUCTION_CHECKPOINT_PATH + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix3d_unetvit/checkpoints/epoch=20-step=67200-loss=0.730.ckpt data: init_args: @@ -36,8 +36,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_pix2pix3d_unetvit__tomm20_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__denv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_PRED_TOMM20_ON_A549_tomm20_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml index 98760a979..b044ea8c0 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: REPLACE_ME_WITH_PRODUCTION_CHECKPOINT_PATH + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix3d_unetvit/checkpoints/epoch=20-step=67200-loss=0.730.ckpt data: init_args: @@ -36,8 +36,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_pix2pix3d_unetvit__tomm20_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__mock/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_PRED_TOMM20_ON_A549_tomm20_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml index de91e33c0..8a6e1ce69 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: REPLACE_ME_WITH_PRODUCTION_CHECKPOINT_PATH + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix3d_unetvit/checkpoints/epoch=20-step=67200-loss=0.730.ckpt data: init_args: @@ -36,8 +36,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_pix2pix3d_unetvit__tomm20_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__zikv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_PRED_TOMM20_ON_A549_tomm20_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__hek_mantis_tomm70a_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__hek_mantis_tomm70a_a549xy.yml new file mode 100644 index 000000000..cf2041d94 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__hek_mantis_tomm70a_a549xy.yml @@ -0,0 +1,49 @@ +# pix2pix3d_unetvit predict: mito trained on ipsc_confocal, +# predicting against the HEK293T third-cell-type probe (TOMM70A, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# mito/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'pix2pix3d_unetvit' (config dir 'pix2pix3d_unetvit'). +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_tomm70a_a549xy.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/pix2pix3d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: hek_mantis_tomm70a_a549xy + model_name: pix2pix3d_unetvit + experiment_id: mito__ipsc_confocal__pix2pix3d_unetvit__hek_mantis_tomm70a_a549xy + dataset_ref: + target: tomm70a +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix3d_unetvit/checkpoints/epoch=20-step=67200-loss=0.730.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/hek__a549xy/prediction.zarr + z_reduction: center +launcher: + job_name: PIX2PIX3D_PRED_MITO_IPSCTR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml index 752d97aa6..8c7f7242e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: REPLACE_ME_WITH_PRODUCTION_CHECKPOINT_PATH + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix3d_unetvit/checkpoints/epoch=20-step=67200-loss=0.730.ckpt data: init_args: @@ -36,8 +36,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_pix2pix3d_unetvit.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/ipsc/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_PRED_TOMM20 - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/train.yml index c44405d4f..3b5065c0b 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/train.yml @@ -27,6 +27,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml new file mode 100644 index 000000000..21b23182b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml @@ -0,0 +1,69 @@ +# pix2pix3d_unetvit MODERNIZED fit on mito (Structure channel of TOMM20.zarr) — AICS iPSC confocal, 4-GPU DDP. +# +# Finalized "Run D" recipe: modernized overlay (nonsat + R1 + G-EMA, equal LR) +# + lambda_l1=10 + LeCam gamma=0.3 + 40 epochs. Mirrors the completed nucleus +# modernized runs (same recipe, Structure channel / TOMM20 store). Submit with NO overrides. +# +# BACKFILL. This leaf was missing while its a549_mantis and joint siblings existed, +# and it was the only gap in the 12-cell pix2pix3d (4 organelles x 3 pools) grid — so +# no iPSC-trained mito GAN was ever trained. wandb (computational_imaging/dynacell) +# holds A549_TOMM20 and JOINT_TOMM20 runs from 2026-07-07/08 and no iPSC_TOMM20 run in +# any state. The gap surfaced on 2026-07-15, when the four iPSC-trained mito predict +# leaves failed in ~30 s with a ValueError naming their placeholder ckpt_path (jobs +# 34881151-53 / 34891026-28); the A549- and joint-trained +# predicts in the same batch failed for an unrelated transient reason and succeeded on +# resubmit, which is how a permanent config gap came to look like shared flakiness. +# The empty Pix2Pix3D column in the paper's iPSC mitochondria table is this hole. +# +# Unlike the a549_mantis sibling there is no `data:` override: A549 needs one because +# its condition-pooled TOMM20_all.zarr has no manifest resolver, whereas iPSC resolves +# data_path / source_channel / target_channel from dataset_ref (aics-hipsc + tomm20), +# exactly as every other iPSC-trained mito fit does. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/data_overlays/unetvit3d_fit.yml + - ../../../_internal/shared/model/model_overlays/pix2pix3d_unetvit_fit_ddp_modernized.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + train_set: ipsc_confocal + model_name: pix2pix3d_unetvit + experiment_id: mito__ipsc_confocal__pix2pix3d_unetvit_modernized + +model: + init_args: + lambda_l1: 10.0 + lecam_gamma: 0.3 + +trainer: + max_epochs: 40 + logger: + init_args: + name: pix2pix3d_unetvit_iPSC_TOMM20_4gpu_modernized_lambdaL1_10_lecam_40ep + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix3d_unetvit + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix3d_unetvit/checkpoints + +launcher: + job_name: pix2pix3d_unetvit_iPSC_TOMM20_4gpu_modernized_lambdaL1_10_lecam_40ep + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/pix2pix3d_unetvit + # pix2pix3d GAN (UNetViT3D G + multiscale-patch D, large 3D crops) OOMs on + # 80 GB h100; needs h200 (141 GB). Narrow the hardware_4gpu h100|h200 default. + sbatch: + constraint: h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index b1521ad49..9f741588a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/pix2pix3d_unetvit/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix3d_unetvit/checkpoints/epoch=27-step=136192.ckpt data: init_args: @@ -36,8 +36,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/tomm20_pix2pix3d_unetvit__tomm20_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__denv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_JOINT_PRED_TOMM20_ON_A549_tomm20_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index 3c2e5a501..519cb5f0c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/pix2pix3d_unetvit/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix3d_unetvit/checkpoints/epoch=27-step=136192.ckpt data: init_args: @@ -36,8 +36,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/tomm20_pix2pix3d_unetvit__tomm20_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__mock/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_JOINT_PRED_TOMM20_ON_A549_tomm20_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index 588766d46..a5342a6fc 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/pix2pix3d_unetvit/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix3d_unetvit/checkpoints/epoch=27-step=136192.ckpt data: init_args: @@ -36,8 +36,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/tomm20_pix2pix3d_unetvit__tomm20_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__zikv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_JOINT_PRED_TOMM20_ON_A549_tomm20_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml new file mode 100644 index 000000000..d0b4094d9 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__hek_mantis_tomm70a_a549xy.yml @@ -0,0 +1,49 @@ +# pix2pix3d_unetvit predict: mito trained on joint_ipsc_confocal_a549_mantis, +# predicting against the HEK293T third-cell-type probe (TOMM70A, a549xy geometry). +# Auto-generated by tools/generate_hek_predict_configs.py from +# mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml — checkpoint and the sibling's +# data/model init_args (normalizations, predict hparams) and prediction-writer +# args lifted verbatim. +# Fit verified to train against a raw (non-deconvolved) GT channel. +# Evaluation-only: no HEK training. Path token is 'pix2pix3d_unetvit' (config dir 'pix2pix3d_unetvit'). +base: +- ../../../_internal/shared/model/predict_sets/hek_mantis_tomm70a_a549xy.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/pix2pix3d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: hek_mantis_tomm70a_a549xy + model_name: pix2pix3d_unetvit + experiment_id: mito__joint_ipsc_confocal_a549_mantis__pix2pix3d_unetvit__hek_mantis_tomm70a_a549xy + dataset_ref: + target: tomm70a +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix3d_unetvit/checkpoints/epoch=27-step=136192.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/hek__a549xy/prediction.zarr + z_reduction: center +launcher: + job_name: PIX2PIX3D_PRED_MITO_JOINTTR_HEK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/hek__a549xy + sbatch: + constraint: a40|l40s|a6000|a100|h100|h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index 8a6899e0e..875e085b3 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/tomm20/pix2pix3d_unetvit/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix3d_unetvit/checkpoints/epoch=27-step=136192.ckpt data: init_args: @@ -36,8 +36,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/tomm20_pix2pix3d_unetvit.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/ipsc/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_JOINT_PRED_TOMM20_ON_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/pix2pix3d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml index 45ce21b8c..9ebe527f1 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml @@ -39,6 +39,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml new file mode 100644 index 000000000..cbe20e1e0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml @@ -0,0 +1,159 @@ +# pix2pix3d_unetvit MODERNIZED fit on mito (Structure marker) — joint ipsc_confocal + a549_mantis pooled, 4-GPU DDP. +# +# Finalized "Run D" recipe: modernized overlay (nonsat + R1 + G-EMA, equal LR) +# + lambda_l1=10 + LeCam gamma=0.3 + 40 epochs. Mirrors the completed nucleus +# modernized runs (same recipe, Structure channel / TOMM20 store). Submit with NO overrides. +# +# Joint leaf. Uses BatchedConcatDataModule with two explicit HCSDataModule +# children (no benchmark.dataset_ref — joint leaves bypass the single-dataset +# resolver). Only model_overlays/pix2pix3d_unetvit_fit.yml is composed; the +# data block is authored inline because joint hparams live on the children. +# +# Normalization is NormalizeSampled (fov_statistics) to match the single-set +# pix2pix3d_unetvit leaves — divergent from the celldiff joint which uses +# MinMaxSampled. Per-organelle prior is to keep joint and single-set +# normalizations identical so ablations are apples-to-apples. +# +# Topology: 4-GPU H200 DDP (recipes/topology/ddp_4gpu_gan via the modernized overlay). +base: + - ../../../_internal/shared/model/model_overlays/pix2pix3d_unetvit_fit_ddp_modernized.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + gene: TOMM20 + target: mito + target_id: mito_tomm20 + train_set: joint_ipsc_confocal_a549_mantis + model_name: pix2pix3d_unetvit + experiment_id: mito__joint_ipsc_confocal_a549_mantis__pix2pix3d_unetvit_modernized + +model: + init_args: + lambda_l1: 10.0 + lecam_gamma: 0.3 + +trainer: + max_epochs: 40 + logger: + init_args: + name: pix2pix3d_unetvit_JOINT_TOMM20_4gpu_modernized_lambdaL1_10_lecam_40ep + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix3d_unetvit + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix3d_unetvit/checkpoints + +# Child HCSDataModule init_args shared across both datasets (only data_path +# differs). `_`-prefixed top-level keys are stripped by load_composed_config +# before reaching LightningCLI; the merge expansion under `data:` survives. +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Structure + z_window_size: 13 + # batch_size=2 + num_samples=2 → 4 GPU samples/step, matching the single-set + # pix2pix3d_unetvit (batch=4, num_samples=2). BatchedConcatDataModule does + # NOT divide by num_samples (see CLAUDE.md), so joint.batch_size = + # single_set.batch_size / num_samples. + batch_size: 2 + num_workers: 4 + yx_patch_size: [512, 512] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Structure] + level: fov_statistics + subtrahend: median + divisor: iqr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Structure] + w_key: Structure + spatial_size: [13, 624, 624] + num_samples: 2 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [3.14, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[0.7, 1.3], [0.5, 1.5], [0.5, 1.5]] + safe_crop_size: [8, 512, 512] + safe_crop_coverage: 0.9 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [8, 512, 512] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0.25, 0.75] + val_gpu_augmentations: + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [8, 512, 512] + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/TOMM20.zarr + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all.zarr + +launcher: + job_name: pix2pix3d_unetvit_JOINT_TOMM20_4gpu_modernized_lambdaL1_10_lecam_40ep + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/pix2pix3d_unetvit + # pix2pix3d GAN (UNetViT3D G + multiscale-patch D, large 3D crops) OOMs on + # 80 GB h100; needs h200 (141 GB). Narrow the hardware_4gpu h100|h200 default. + sbatch: + constraint: h200 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..9e4b11088 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,43 @@ +# unetvit3d predict: mito (TOMM20) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_denv + model_name: unetvit3d + experiment_id: mito__a549_mantis__unetvit3d__a549_mantis_tomm20_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/unetvit3d/checkpoints/epoch=16-step=53550.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/a549__denv/prediction.zarr + +launcher: + job_name: UNetViT3D_PRED_TOMM20_A549TR_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..676f69061 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_denv_lite + model_name: unetvit3d + experiment_id: mito__a549_mantis__unetvit3d__a549_mantis_tomm20_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/unetvit3d/checkpoints/epoch=16-step=53550.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/a549/a549__denv/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_TOMM20_A549TR_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..302d13ce1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,43 @@ +# unetvit3d predict: mito (TOMM20) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_mock + model_name: unetvit3d + experiment_id: mito__a549_mantis__unetvit3d__a549_mantis_tomm20_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/unetvit3d/checkpoints/epoch=16-step=53550.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/a549__mock/prediction.zarr + +launcher: + job_name: UNetViT3D_PRED_TOMM20_A549TR_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..68059ea15 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_mock_lite + model_name: unetvit3d + experiment_id: mito__a549_mantis__unetvit3d__a549_mantis_tomm20_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/unetvit3d/checkpoints/epoch=16-step=53550.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/a549/a549__mock/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_TOMM20_A549TR_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..33374d103 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,43 @@ +# unetvit3d predict: mito (TOMM20) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_zikv + model_name: unetvit3d + experiment_id: mito__a549_mantis__unetvit3d__a549_mantis_tomm20_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/unetvit3d/checkpoints/epoch=16-step=53550.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/a549__zikv/prediction.zarr + +launcher: + job_name: UNetViT3D_PRED_TOMM20_A549TR_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..69e48a830 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: a549_mantis_tomm20_zikv_lite + model_name: unetvit3d + experiment_id: mito__a549_mantis__unetvit3d__a549_mantis_tomm20_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/unetvit3d/checkpoints/epoch=16-step=53550.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/a549/a549__zikv/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_TOMM20_A549TR_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..ed3db62f5 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,43 @@ +# unetvit3d predict: mito (TOMM20) trained on a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: unetvit3d + experiment_id: mito__a549_mantis__unetvit3d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/unetvit3d/checkpoints/epoch=16-step=53550.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/ipsc/prediction.zarr + +launcher: + job_name: UNetViT3D_PRED_TOMM20_A549TR_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..40fcb2175 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: a549_mantis + predict_set: ipsc_confocal_lite + model_name: unetvit3d + experiment_id: mito__a549_mantis__unetvit3d__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/unetvit3d/checkpoints/epoch=16-step=53550.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/a549/ipsc/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_TOMM20_A549TR_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/train.yml index 4b0dfed93..4bf2ff1b8 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/a549_mantis/train.yml @@ -19,7 +19,7 @@ trainer: logger: init_args: name: UNetViT3D_A549_TOMM20 - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/tomm20/unetvit3d + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/unetvit3d callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -27,17 +27,19 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/tomm20/unetvit3d/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/unetvit3d/checkpoints data: init_args: # A549 pooled store + target_channel — no resolver in this train_set. target_channel: Structure - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/TOMM20_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all.zarr launcher: job_name: UNetViT3D_A549_TOMM20 - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/tomm20/unetvit3d + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/mito/unetvit3d diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index 5ed7260c0..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Mitochondria (TOMM20) predicted by UNetViT3D on a549-mantis-tomm20-denv. -defaults: - - override /target: mito_tomm20 - - override /predict_set: a549_mantis_tomm20_denv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_unetvit3d__tomm20_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_tomm20_unetvit3d__tomm20_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index 21d60504c..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Mitochondria (TOMM20) predicted by UNetViT3D on a549-mantis-tomm20-mock. -defaults: - - override /target: mito_tomm20 - - override /predict_set: a549_mantis_tomm20_mock - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_unetvit3d__tomm20_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_tomm20_unetvit3d__tomm20_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index bf8c596a1..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Mitochondria (TOMM20) predicted by UNetViT3D on a549-mantis-tomm20-zikv. -defaults: - - override /target: mito_tomm20 - - override /predict_set: a549_mantis_tomm20_zikv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_unetvit3d__tomm20_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_tomm20_unetvit3d__tomm20_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 100644 index e85266660..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Mitochondria (TOMM20) predicted by UNetViT3D on iPSC confocal. -defaults: - - override /target: mito_tomm20 - - override /predict_set: ipsc_confocal - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_unetvit3d.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/eval_tomm20_unetvit3d diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml index b80257994..6037695dc 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/tomm20/unetvit3d/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/unetvit3d/checkpoints/epoch=19-step=128000.ckpt data: init_args: @@ -36,8 +36,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_unetvit3d__tomm20_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/a549__denv/prediction.zarr launcher: job_name: UNetViT3D_PRED_TOMM20_ON_A549_tomm20_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..989b89bb1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_denv_lite + model_name: unetvit3d + experiment_id: mito__ipsc_confocal__unetvit3d__a549_mantis_tomm20_denv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/unetvit3d/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/ipsc/a549__denv/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_TOMM20_ON_A549_tomm20_denv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml index 9e403ac5c..b37e1d2f4 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/tomm20/unetvit3d/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/unetvit3d/checkpoints/epoch=19-step=128000.ckpt data: init_args: @@ -36,8 +36,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_unetvit3d__tomm20_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/a549__mock/prediction.zarr launcher: job_name: UNetViT3D_PRED_TOMM20_ON_A549_tomm20_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..2638af2e7 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_mock_lite + model_name: unetvit3d + experiment_id: mito__ipsc_confocal__unetvit3d__a549_mantis_tomm20_mock__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/unetvit3d/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/ipsc/a549__mock/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_TOMM20_ON_A549_tomm20_mock_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml index 08f7cfeb6..57f6f1d8a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/tomm20/unetvit3d/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/unetvit3d/checkpoints/epoch=19-step=128000.ckpt data: init_args: @@ -36,8 +36,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/tomm20_unetvit3d__tomm20_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/a549__zikv/prediction.zarr launcher: job_name: UNetViT3D_PRED_TOMM20_ON_A549_tomm20_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..c39a56d41 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: a549_mantis_tomm20_zikv_lite + model_name: unetvit3d + experiment_id: mito__ipsc_confocal__unetvit3d__a549_mantis_tomm20_zikv__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/unetvit3d/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_TOMM20_ON_A549_tomm20_zikv_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml index c42fa98a2..7e11fe75f 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/tomm20/unetvit3d/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/unetvit3d/checkpoints/epoch=19-step=128000.ckpt data: init_args: @@ -36,8 +36,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/tomm20_unetvit3d.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/ipsc/prediction.zarr launcher: job_name: UNetViT3D_PRED_TOMM20 - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..083e82a29 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/mito_tomm20.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: mito + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: unetvit3d + experiment_id: mito__ipsc_confocal__unetvit3d__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/unetvit3d/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/ipsc/ipsc/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_TOMM20_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/mito/unetvit3d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/train.yml index 47941d508..0df711f7c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/ipsc_confocal/train.yml @@ -19,7 +19,7 @@ trainer: logger: init_args: name: UNetViT3D_iPSC_TOMM20 - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/tomm20/unetvit3d + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/unetvit3d callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -27,11 +27,13 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/tomm20/unetvit3d/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/unetvit3d/checkpoints launcher: job_name: UNetViT3D_TOMM20 - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/tomm20/unetvit3d + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/mito/unetvit3d diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..41d69645d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,43 @@ +# unetvit3d predict: mito (TOMM20) trained on joint_ipsc_confocal_a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_denv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_denv + model_name: unetvit3d + experiment_id: mito__joint_ipsc_confocal_a549_mantis__unetvit3d__a549_mantis_tomm20_denv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/unetvit3d/checkpoints/epoch=19-step=189200.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/a549__denv/prediction.zarr + +launcher: + job_name: UNetViT3D_PRED_TOMM20_JOINTTR_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..90c17628d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,43 @@ +# unetvit3d predict: mito (TOMM20) trained on joint_ipsc_confocal_a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_mock.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_mock + model_name: unetvit3d + experiment_id: mito__joint_ipsc_confocal_a549_mantis__unetvit3d__a549_mantis_tomm20_mock + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/unetvit3d/checkpoints/epoch=19-step=189200.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/a549__mock/prediction.zarr + +launcher: + job_name: UNetViT3D_PRED_TOMM20_JOINTTR_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..82e739be5 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,43 @@ +# unetvit3d predict: mito (TOMM20) trained on joint_ipsc_confocal_a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_tomm20_zikv.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_tomm20_zikv + model_name: unetvit3d + experiment_id: mito__joint_ipsc_confocal_a549_mantis__unetvit3d__a549_mantis_tomm20_zikv + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/unetvit3d/checkpoints/epoch=19-step=189200.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/a549__zikv/prediction.zarr + +launcher: + job_name: UNetViT3D_PRED_TOMM20_JOINTTR_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..28f1743fb --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,43 @@ +# unetvit3d predict: mito (TOMM20) trained on joint_ipsc_confocal_a549_mantis. Gap-fill predict leaf (2026-07-14). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/mito_tomm20.yml + - ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: mito + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: unetvit3d + experiment_id: mito__joint_ipsc_confocal_a549_mantis__unetvit3d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/unetvit3d/checkpoints/epoch=19-step=189200.ckpt + +data: + init_args: + # override target-inherited normalizations: predict only reads source + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + # clear target-inherited RandWeightedCropd; predict has no CPU augs + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/ipsc/prediction.zarr + +launcher: + job_name: UNetViT3D_PRED_TOMM20_JOINTTR_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/mito/unetvit3d/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/train.yml index 49f9a631d..f44539d62 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/mito/unetvit3d/joint_ipsc_confocal_a549_mantis/train.yml @@ -29,7 +29,7 @@ trainer: logger: init_args: name: UNetViT3D_JOINT_TOMM20 - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/tomm20/unetvit3d + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/unetvit3d callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -37,16 +37,21 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/tomm20/unetvit3d/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/unetvit3d/checkpoints _hcs_init_args: &hcs_init_args source_channel: Phase3D target_channel: Structure z_window_size: 13 - batch_size: 4 + # batch_size=2 + num_samples=2 -> 4 GPU samples/step, matching the single-set + # unetvit3d (batch=4, num_samples=2). BatchedConcatDataModule does NOT divide + # by num_samples (see CLAUDE.md), so joint.batch_size = single/num_samples. + batch_size: 2 num_workers: 4 yx_patch_size: [512, 512] split_ratio: 0.8 @@ -127,11 +132,11 @@ data: - class_path: viscy_data.hcs.HCSDataModule init_args: <<: *hcs_init_args - data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/TOMM20_all.zarr + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all.zarr launcher: job_name: UNetViT3D_JOINT_TOMM20 - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/tomm20/unetvit3d + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/mito/unetvit3d # Joint preloads two stores (iPSC + A549 pool) into /dev/shm; the default # 256G cap is too tight (256G iPSC mem + ~50G A549 + worker peak OOMs). # 512G is the smallest tier that fits joint preload + worker overhead. diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_denv.yml index 1ae97abd8..afe3d076d 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_denv.yml @@ -5,7 +5,7 @@ base: - ../../../_internal/shared/model/targets/nucleus.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -20,7 +20,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/nucl/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -38,8 +38,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_r2_a549trained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/a549__denv/prediction.zarr launcher: job_name: CELLDiff_A549_PRED_NUCL_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..c167fe2d1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,38 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_denv_lite + model_name: celldiff + experiment_id: nucleus__a549_mantis__celldiff__a549_mantis_h2b_denv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/a549/a549__denv/prediction.zarr +launcher: + job_name: CELLDiff_A549_PRED_NUCL_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_mock.yml index 34e90c068..2dc48c134 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_mock.yml @@ -5,7 +5,7 @@ base: - ../../../_internal/shared/model/targets/nucleus.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -20,7 +20,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/nucl/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -38,8 +38,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_r2_a549trained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/a549__mock/prediction.zarr launcher: job_name: CELLDiff_A549_PRED_NUCL_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..0abbe4dba --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,38 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_mock_lite + model_name: celldiff + experiment_id: nucleus__a549_mantis__celldiff__a549_mantis_h2b_mock__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/a549/a549__mock/prediction.zarr +launcher: + job_name: CELLDiff_A549_PRED_NUCL_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_movie.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_movie.yml new file mode 100644 index 000000000..1ccecb01d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_movie.yml @@ -0,0 +1,47 @@ +# CellDiff r2 predict: nucleus trained on a549_mantis, predicting on the +# cropped A549 TOMM20 DENV movie zarr (125 timepoints). +# No predict_set base — data path set directly to bypass the manifest system. +base: + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_movie + model_name: celldiff + experiment_id: nucleus__a549_mantis__celldiff__a549_mantis_movie + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt + predict_method: iterative + predict_overlap: [4, 256, 256] + +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/movie/2024_11_21_A549_TOMM20_DENV_crop.zarr + source_channel: Phase3D + target_channel: Nucleus + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + z_window_size: 48 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/a549/movie_predictions/nucl_celldiff_r2_a549trained_movie.zarr + +launcher: + job_name: CELLDiff_A549_PRED_NUCL_MOVIE + run_root: /hpc/projects/virtual_staining/training/dynacell/a549/movie_predictions diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_zikv.yml index 8c2f3adc9..1685fdb51 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_zikv.yml @@ -5,7 +5,7 @@ base: - ../../../_internal/shared/model/targets/nucleus.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -20,7 +20,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/nucl/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -38,8 +38,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_r2_a549trained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/a549__zikv/prediction.zarr launcher: job_name: CELLDiff_A549_PRED_NUCL_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..491408b64 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,38 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_zikv_lite + model_name: celldiff + experiment_id: nucleus__a549_mantis__celldiff__a549_mantis_h2b_zikv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/a549/a549__zikv/prediction.zarr +launcher: + job_name: CELLDiff_A549_PRED_NUCL_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__ipsc_confocal.yml index 0b03fb4cf..fd6046441 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__ipsc_confocal.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/nucleus.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/nucl/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_celldiff_r2_a549trained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/ipsc/prediction.zarr launcher: job_name: CELLDiff_A549_PRED_NUCL_ON_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..0e037380d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: ipsc_confocal_lite + model_name: celldiff + experiment_id: nucleus__a549_mantis__celldiff__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 40 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/a549/ipsc/prediction.zarr +launcher: + job_name: CELLDiff_A549_PRED_NUCL_ON_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/train.yml index a47726292..305151a51 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis/train.yml @@ -19,7 +19,7 @@ trainer: logger: init_args: name: CELLDiff_A549_NUCL - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/nucl/celldiff_r2 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/celldiff_r2 callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -29,7 +29,7 @@ trainer: every_n_epochs: 1 save_top_k: -1 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/nucl/celldiff_r2/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/celldiff_r2/checkpoints data: init_args: @@ -39,4 +39,4 @@ data: launcher: job_name: CELLDiff_A549_NUCL - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/nucl/celldiff_r2 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/celldiff_r2 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..bc69b445c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# CELLDiffBF predict: nucleus trained on a549_mantis_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_h2b_denv. +# +# Brightfield-input ablation arm of +# nucleus/celldiff/a549_mantis/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `a549__bf`). +# +# save_top_k: -1 with no monitor on this arm, so the checkpoint is the FINAL +# epoch chosen explicitly, matching how the phase baseline pinned its own. +# +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side +# `nucleus` target_id from targets/nucleus.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis_brightfield + predict_set: a549_mantis_h2b_denv + model_name: celldiff + experiment_id: nucleus__a549_mantis_brightfield__celldiff__a549_mantis_h2b_denv + dataset_ref: + source_channel: Brightfield + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/nucleus/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt + predict_method: iterative + predict_overlap: [4, 256, 256] + +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + augmentations: [] + z_window_size: 48 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/a549__bf/a549__denv/prediction.zarr + +launcher: + job_name: CELLDiffBF_PRED_NUCL_A549TR_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/a549__bf/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..48aeb9c16 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# CELLDiffBF predict: nucleus trained on a549_mantis_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_h2b_mock. +# +# Brightfield-input ablation arm of +# nucleus/celldiff/a549_mantis/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `a549__bf`). +# +# save_top_k: -1 with no monitor on this arm, so the checkpoint is the FINAL +# epoch chosen explicitly, matching how the phase baseline pinned its own. +# +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side +# `nucleus` target_id from targets/nucleus.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis_brightfield + predict_set: a549_mantis_h2b_mock + model_name: celldiff + experiment_id: nucleus__a549_mantis_brightfield__celldiff__a549_mantis_h2b_mock + dataset_ref: + source_channel: Brightfield + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/nucleus/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt + predict_method: iterative + predict_overlap: [4, 256, 256] + +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + augmentations: [] + z_window_size: 48 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/a549__bf/a549__mock/prediction.zarr + +launcher: + job_name: CELLDiffBF_PRED_NUCL_A549TR_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/a549__bf/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..c6440a7d2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# CELLDiffBF predict: nucleus trained on a549_mantis_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_h2b_zikv. +# +# Brightfield-input ablation arm of +# nucleus/celldiff/a549_mantis/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `a549__bf`). +# +# save_top_k: -1 with no monitor on this arm, so the checkpoint is the FINAL +# epoch chosen explicitly, matching how the phase baseline pinned its own. +# +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side +# `nucleus` target_id from targets/nucleus.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis_brightfield + predict_set: a549_mantis_h2b_zikv + model_name: celldiff + experiment_id: nucleus__a549_mantis_brightfield__celldiff__a549_mantis_h2b_zikv + dataset_ref: + source_channel: Brightfield + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/nucleus/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt + predict_method: iterative + predict_overlap: [4, 256, 256] + +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + augmentations: [] + z_window_size: 48 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/a549__bf/a549__zikv/prediction.zarr + +launcher: + job_name: CELLDiffBF_PRED_NUCL_A549TR_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/a549__bf/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/predict__ipsc_confocal__iterative.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/predict__ipsc_confocal__iterative.yml new file mode 100644 index 000000000..73e09c3a0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/predict__ipsc_confocal__iterative.yml @@ -0,0 +1,55 @@ +# CELLDiffBF predict: nucleus trained on a549_mantis_brightfield, BRIGHTFIELD input, +# predicting against ipsc_confocal. +# +# Brightfield-input ablation arm of +# nucleus/celldiff/a549_mantis/predict__ipsc*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `a549__bf`). +# +# save_top_k: -1 with no monitor on this arm, so the checkpoint is the FINAL +# epoch chosen explicitly, matching how the phase baseline pinned its own. + +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis_brightfield + predict_set: ipsc_confocal + model_name: celldiff + experiment_id: nucleus__a549_mantis_brightfield__celldiff__ipsc_confocal__iterative + dataset_ref: + source_channel: Brightfield + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/nucleus/celldiff_r2/checkpoints/epoch=19-step=86400.ckpt + predict_method: iterative + predict_overlap: [4, 256, 256] + +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + augmentations: [] + z_window_size: 40 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/a549__bf/ipsc/prediction.zarr + +launcher: + job_name: CELLDiffBF_PRED_NUCL_A549TR_ITER_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/a549__bf/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/train.yml new file mode 100644 index 000000000..549efba27 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/a549_mantis_brightfield/train.yml @@ -0,0 +1,68 @@ +# CellDiff fit on nucleus — A549 mantis-lightsheet pooled, BRIGHTFIELD input. +# +# Brightfield-input ablation arm of nucleus/celldiff/a549_mantis/train.yml. Every +# hyperparameter is identical to that baseline; the only change is the model input +# channel (Brightfield instead of the Phase3D volume reconstructed from it), which +# enters via train_sets/a549_mantis_brightfield.yml's source_channel. +# +# Only the two channel-named lists are re-authored. gpu_augmentations and +# val_gpu_augmentations key on `source`/`target` (post-collation names), so they are +# channel-agnostic and inherited from data_overlays/celldiff_fit.yml untouched. +# val_augmentations is deliberately absent, matching the baseline. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis_brightfield.yml + - ../../../_internal/shared/model/targets/nucleus_celldiff.yml + - ../../../_internal/shared/model/data_overlays/celldiff_fit.yml + - ../../../_internal/shared/model/model_overlays/celldiff_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: a549_mantis_brightfield + model_name: celldiff + experiment_id: nucleus__a549_mantis_brightfield__celldiff + +data: + init_args: + # A549 pooled store + target_channel — no resolver in this train_set. + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/H2B_all.zarr + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Nuclei] + level: timepoint_statistics + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Brightfield, Nuclei] + w_key: Nuclei + spatial_size: [13, 624, 624] + num_samples: 2 + +trainer: + logger: + init_args: + name: CELLDiff_A549bf_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/nucleus/celldiff_r2 + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + every_n_epochs: 1 + save_top_k: -1 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/nucleus/celldiff_r2/checkpoints + +launcher: + job_name: CELLDiffBF_A549_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/nucleus/celldiff_r2 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index ab2c3d60e..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Nucleus (H2B) predicted by CellDiff on a549-mantis-h2b-denv. -# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` -# target_id from the target group so the resolver finds h2b on a549-mantis-h2b-denv. -defaults: - - override /target: nucleus - - override /predict_set: a549_mantis_h2b_denv - -benchmark: - dataset_ref: - target: h2b - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_denoise_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_nucl_celldiff_denoise_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index aa56bb8fb..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Nucleus (H2B) predicted by CellDiff on a549-mantis-h2b-mock. -# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` -# target_id from the target group so the resolver finds h2b on a549-mantis-h2b-mock. -defaults: - - override /target: nucleus - - override /predict_set: a549_mantis_h2b_mock - -benchmark: - dataset_ref: - target: h2b - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_denoise_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_nucl_celldiff_denoise_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index 5c716eadf..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Nucleus (H2B) predicted by CellDiff on a549-mantis-h2b-zikv. -# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` -# target_id from the target group so the resolver finds h2b on a549-mantis-h2b-zikv. -defaults: - - override /target: nucleus - - override /predict_set: a549_mantis_h2b_zikv - -benchmark: - dataset_ref: - target: h2b - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_denoise_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_nucl_celldiff_denoise_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 100644 index a013096af..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Nucleus predicted by CellDiff on iPSC confocal. -defaults: - - override /target: nucleus - - override /predict_set: ipsc_confocal - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_celldiff_denoise.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/eval_nucl_celldiff_denoise diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml index d3db6f04c..9bf54d501 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/nucleus.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt predict_method: iterative # denoise, generate, sliding_window, or iterative predict_overlap: [4, 256, 256] @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_r2_iterative_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr launcher: job_name: CELLDiff_PRED_NUCL_ON_A549_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..e3a326271 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,38 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv_lite + model_name: celldiff + experiment_id: nucleus__ipsc_confocal__celldiff__a549_mantis_h2b_denv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2_iterative/ipsc/a549__denv/prediction.zarr +launcher: + job_name: CELLDiff_PRED_NUCL_ON_A549_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2_iterative/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml index 657990b21..67a9aeef5 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/nucleus.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt predict_method: iterative # denoise, generate, sliding_window, or iterative predict_overlap: [4, 256, 256] @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_r2_iterative_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr launcher: job_name: CELLDiff_PRED_NUCL_ON_A549_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..70247a15b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,38 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock_lite + model_name: celldiff + experiment_id: nucleus__ipsc_confocal__celldiff__a549_mantis_h2b_mock__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2_iterative/ipsc/a549__mock/prediction.zarr +launcher: + job_name: CELLDiff_PRED_NUCL_ON_A549_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2_iterative/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml index e7a2411c8..b6e9e0e1d 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/nucleus.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt predict_method: iterative # denoise, generate, sliding_window, or iterative predict_overlap: [4, 256, 256] @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_celldiff_r2_iterative_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr launcher: job_name: CELLDiff_PRED_NUCL_ON_A549_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..3de094ddc --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,38 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv_lite + model_name: celldiff + experiment_id: nucleus__ipsc_confocal__celldiff__a549_mantis_h2b_zikv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2_iterative/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: CELLDiff_PRED_NUCL_ON_A549_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2_iterative/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__ipsc_confocal__denoise.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__ipsc_confocal__denoise.yml index ea5a1dbd7..9c837bf30 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__ipsc_confocal__denoise.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__ipsc_confocal__denoise.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/nucleus.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt predict_method: denoise predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_celldiff_r2_denoise.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_denoise/ipsc/ipsc/prediction.zarr launcher: job_name: CELLDiff_PRED_NUCL_DN - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_denoise/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml index 271a2de90..8a42278c4 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/nucleus.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_celldiff_r2_iterative.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr launcher: job_name: CELLDiff_PRED_NUCL_ITER - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative_lite.yml new file mode 100644 index 000000000..d3d87a491 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__ipsc_confocal__iterative.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: celldiff + experiment_id: nucleus__ipsc_confocal__celldiff__ipsc_confocal__iterative__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 40 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2_iterative/ipsc/ipsc/prediction.zarr +launcher: + job_name: CELLDiff_PRED_NUCL_ITER_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2_iterative/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__ipsc_confocal__sliding_window.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__ipsc_confocal__sliding_window.yml index 157c62433..5c7676da5 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__ipsc_confocal__sliding_window.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/predict__ipsc_confocal__sliding_window.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/nucleus.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt predict_method: sliding_window predict_overlap: [0, 0, 0] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_celldiff_r2_sliding_window.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_sliding_window/ipsc/ipsc/prediction.zarr launcher: job_name: CELLDiff_PRED_NUCL_SW - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_sliding_window/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/train.yml index 7bb175b56..b9f704b9e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal/train.yml @@ -19,7 +19,7 @@ trainer: logger: init_args: name: CELLDiff_iPSC_NUCL - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/celldiff_r2 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_r2 callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -29,8 +29,8 @@ trainer: every_n_epochs: 1 save_top_k: -1 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/celldiff_r2/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_r2/checkpoints launcher: job_name: CELLDiff_NUCL - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/celldiff_r2 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_r2 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..e4b0ddb81 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# CELLDiffBF predict: nucleus trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_h2b_denv. +# +# Brightfield-input ablation arm of +# nucleus/celldiff/ipsc_confocal/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `ipsc__bf`). +# +# save_top_k: -1 with no monitor on this arm, so the checkpoint is the FINAL +# epoch chosen explicitly, matching how the phase baseline pinned its own. +# +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side +# `nucleus` target_id from targets/nucleus.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal_brightfield + predict_set: a549_mantis_h2b_denv + model_name: celldiff + experiment_id: nucleus__ipsc_confocal_brightfield__celldiff__a549_mantis_h2b_denv + dataset_ref: + source_channel: Brightfield + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt + predict_method: iterative + predict_overlap: [4, 256, 256] + +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + augmentations: [] + z_window_size: 48 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc__bf/a549__denv/prediction.zarr + +launcher: + job_name: CELLDiffBF_PRED_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc__bf/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..e19cd31b4 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# CELLDiffBF predict: nucleus trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_h2b_mock. +# +# Brightfield-input ablation arm of +# nucleus/celldiff/ipsc_confocal/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `ipsc__bf`). +# +# save_top_k: -1 with no monitor on this arm, so the checkpoint is the FINAL +# epoch chosen explicitly, matching how the phase baseline pinned its own. +# +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side +# `nucleus` target_id from targets/nucleus.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal_brightfield + predict_set: a549_mantis_h2b_mock + model_name: celldiff + experiment_id: nucleus__ipsc_confocal_brightfield__celldiff__a549_mantis_h2b_mock + dataset_ref: + source_channel: Brightfield + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt + predict_method: iterative + predict_overlap: [4, 256, 256] + +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + augmentations: [] + z_window_size: 48 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc__bf/a549__mock/prediction.zarr + +launcher: + job_name: CELLDiffBF_PRED_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc__bf/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..e4bb92310 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# CELLDiffBF predict: nucleus trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_h2b_zikv. +# +# Brightfield-input ablation arm of +# nucleus/celldiff/ipsc_confocal/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `ipsc__bf`). +# +# save_top_k: -1 with no monitor on this arm, so the checkpoint is the FINAL +# epoch chosen explicitly, matching how the phase baseline pinned its own. +# +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side +# `nucleus` target_id from targets/nucleus.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal_brightfield + predict_set: a549_mantis_h2b_zikv + model_name: celldiff + experiment_id: nucleus__ipsc_confocal_brightfield__celldiff__a549_mantis_h2b_zikv + dataset_ref: + source_channel: Brightfield + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt + predict_method: iterative + predict_overlap: [4, 256, 256] + +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + augmentations: [] + z_window_size: 48 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc__bf/a549__zikv/prediction.zarr + +launcher: + job_name: CELLDiffBF_PRED_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc__bf/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/predict__ipsc_confocal__iterative.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/predict__ipsc_confocal__iterative.yml new file mode 100644 index 000000000..a04795fae --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/predict__ipsc_confocal__iterative.yml @@ -0,0 +1,55 @@ +# CELLDiffBF predict: nucleus trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against ipsc_confocal. +# +# Brightfield-input ablation arm of +# nucleus/celldiff/ipsc_confocal/predict__ipsc*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `ipsc__bf`). +# +# save_top_k: -1 with no monitor on this arm, so the checkpoint is the FINAL +# epoch chosen explicitly, matching how the phase baseline pinned its own. + +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal_brightfield + predict_set: ipsc_confocal + model_name: celldiff + experiment_id: nucleus__ipsc_confocal_brightfield__celldiff__ipsc_confocal__iterative + dataset_ref: + source_channel: Brightfield + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/celldiff_r2/checkpoints/epoch=19-step=128000.ckpt + predict_method: iterative + predict_overlap: [4, 256, 256] + +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + augmentations: [] + z_window_size: 40 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc__bf/ipsc/prediction.zarr + +launcher: + job_name: CELLDiffBF_PRED_NUCL_ITER + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2_iterative/ipsc__bf/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/train.yml new file mode 100644 index 000000000..98c9ff4d0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/ipsc_confocal_brightfield/train.yml @@ -0,0 +1,65 @@ +# CellDiff fit on nucleus (Nuclei channel of cell.zarr) — AICS iPSC confocal, BRIGHTFIELD input. +# +# Brightfield-input ablation arm of nucleus/celldiff/ipsc_confocal/train.yml. Every +# hyperparameter is identical to that baseline; the only change is the model input +# channel (Brightfield instead of the Phase3D volume reconstructed from it), which +# enters via train_sets/ipsc_confocal_brightfield.yml's dataset_ref.source_channel. +# +# Only the two channel-named lists are re-authored. gpu_augmentations and +# val_gpu_augmentations key on `source`/`target` (post-collation names), so they are +# channel-agnostic and inherited from data_overlays/celldiff_fit.yml untouched. +# val_augmentations is deliberately absent, matching the baseline. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal_brightfield.yml + - ../../../_internal/shared/model/targets/nucleus_celldiff.yml + - ../../../_internal/shared/model/data_overlays/celldiff_fit.yml + - ../../../_internal/shared/model/model_overlays/celldiff_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: ipsc_confocal_brightfield + model_name: celldiff + experiment_id: nucleus__ipsc_confocal_brightfield__celldiff + +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Brightfield] + level: timepoint_statistics + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Nuclei] + level: timepoint_statistics + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Brightfield, Nuclei] + w_key: Nuclei + spatial_size: [13, 624, 624] + num_samples: 2 + +trainer: + logger: + init_args: + name: CELLDiff_iPSCbf_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/celldiff_r2 + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + every_n_epochs: 1 + save_top_k: -1 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/celldiff_r2/checkpoints + +launcher: + job_name: CELLDiffBF_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/celldiff_r2 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index a65627875..e1dbbf236 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/nucleus.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/nucl/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/celldiff_r2/checkpoints/epoch=19-step=214400.ckpt predict_method: iterative # denoise, generate, sliding_window, or iterative predict_overlap: [4, 256, 256] @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_celldiff_r2_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/a549__denv/prediction.zarr launcher: job_name: CELLDiff_JOINT_PRED_NUCL_ON_A549_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..028fdf044 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,38 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_denv_lite + model_name: celldiff + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__celldiff__a549_mantis_h2b_denv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/celldiff_r2/checkpoints/epoch=19-step=214400.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/joint/a549__denv/prediction.zarr +launcher: + job_name: CELLDiff_JOINT_PRED_NUCL_ON_A549_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index ebba8dd10..d9358a2d6 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/nucleus.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/nucl/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/celldiff_r2/checkpoints/epoch=19-step=214400.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_celldiff_r2_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/a549__mock/prediction.zarr launcher: job_name: CELLDiff_JOINT_PRED_NUCL_ON_A549_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..401bc77cf --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,38 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_mock_lite + model_name: celldiff + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__celldiff__a549_mantis_h2b_mock__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/celldiff_r2/checkpoints/epoch=19-step=214400.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/joint/a549__mock/prediction.zarr +launcher: + job_name: CELLDiff_JOINT_PRED_NUCL_ON_A549_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index 30b4542f8..1bf32b2eb 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/nucleus.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/nucl/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/celldiff_r2/checkpoints/epoch=19-step=214400.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_celldiff_r2_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/a549__zikv/prediction.zarr launcher: job_name: CELLDiff_JOINT_PRED_NUCL_ON_A549_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..3b5177105 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,38 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_zikv_lite + model_name: celldiff + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__celldiff__a549_mantis_h2b_zikv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/celldiff_r2/checkpoints/epoch=19-step=214400.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 48 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/joint/a549__zikv/prediction.zarr +launcher: + job_name: CELLDiff_JOINT_PRED_NUCL_ON_A549_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index 1d3c7d874..15a6f6231 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -4,7 +4,7 @@ base: - ../../../_internal/shared/model/targets/nucleus.yml - ../../../_internal/shared/model/model_overlays/celldiff_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/nucl/celldiff_r2/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/celldiff_r2/checkpoints/epoch=19-step=214400.ckpt predict_method: iterative predict_overlap: [4, 256, 256] @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/nucl_celldiff_r2.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/ipsc/prediction.zarr launcher: job_name: CELLDiff_JOINT_PRED_NUCL_ON_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_r2/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..9def9da37 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,36 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/celldiff_predict_lite.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff_lite.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal_lite + model_name: celldiff + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__celldiff__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/celldiff_r2/checkpoints/epoch=19-step=214400.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] + z_window_size: 40 +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/joint/ipsc/prediction.zarr +launcher: + job_name: CELLDiff_JOINT_PRED_NUCL_ON_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/celldiff_r2/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/train.yml index cfae02837..22270ee08 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff/joint_ipsc_confocal_a549_mantis/train.yml @@ -33,7 +33,7 @@ trainer: logger: init_args: name: CELLDiff_JOINT_NUCL - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/nucl/celldiff_r2 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/celldiff_r2 callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -43,7 +43,7 @@ trainer: every_n_epochs: 1 save_top_k: -1 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/nucl/celldiff_r2/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/celldiff_r2/checkpoints _hcs_init_args: &hcs_init_args source_channel: Phase3D @@ -133,7 +133,7 @@ data: launcher: job_name: CELLDiff_JOINT_NUCL - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/nucl/celldiff_r2 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/celldiff_r2 # Joint preloads two stores (iPSC + A549 pool) into /dev/shm; the default # 256G cap is too tight (256G iPSC mem + ~50G A549 + worker peak OOMs). # 512G is the smallest tier that fits joint preload + worker overhead. diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..17bbeb966 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# CellDiff-2D predict: nucleus trained on a549_mantis, tested on a549-mantis-h2b-denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_denv + model_name: celldiff_2d + experiment_id: nucleus__a549_mantis__celldiff_2d__a549_mantis_h2b_denv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_denv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/celldiff_2d/checkpoints/epoch=19-step=12000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/a549__denv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_A549_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..4fe7521eb --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# CellDiff-2D predict: nucleus trained on a549_mantis, tested on a549-mantis-h2b-mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_mock + model_name: celldiff_2d + experiment_id: nucleus__a549_mantis__celldiff_2d__a549_mantis_h2b_mock + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_mock. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/celldiff_2d/checkpoints/epoch=19-step=12000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/a549__mock/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_A549_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..23d58a153 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# CellDiff-2D predict: nucleus trained on a549_mantis, tested on a549-mantis-h2b-zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_zikv + model_name: celldiff_2d + experiment_id: nucleus__a549_mantis__celldiff_2d__a549_mantis_h2b_zikv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_zikv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/celldiff_2d/checkpoints/epoch=19-step=12000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/a549__zikv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_A549_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..0f640814f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: nucleus trained on a549_mantis, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: celldiff_2d + experiment_id: nucleus__a549_mantis__celldiff_2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/celldiff_2d/checkpoints/epoch=19-step=12000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/ipsc/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_A549_NUCL_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/train.yml new file mode 100644 index 000000000..5f9a41884 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/a549_mantis/train.yml @@ -0,0 +1,82 @@ +# CellDiff-2D (CELLDiffNet run Z-preserving at Z=1) fit on nucleus (Nuclei +# channel) — a549_mantis, in-focus 2D track. Mirror of the 3D +# nucleus/celldiff/a549_mantis fit leaf, flattened onto the offline +# 5-plane in-focus slab store (z_window_size=1 emits one in-focus window +# per plane). +# +# The 3D leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus store. +# The 2D track reads the `_focus.zarr` slab instead, so the resolver is +# disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field +# co-declared with a full dataset_ref. +# +# The train_set fragment supplies data.class_path (HCSDataModule) plus +# split_ratio / mmap_preload / scratch_dir — without it the resolved +# config has an init_args-only data block and `dynacell fit` fails to +# build the datamodule. targets/nucleus_celldiff.yml supplies the +# MinMaxSampled(timepoint_statistics) normalization CellDiff needs +# (p1/p99 -> [-1,1], not mean/std); only its RandWeightedCropd is +# list-replaced below, flattened [13,624,624] -> [1,624,624]. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/nucleus_celldiff.yml + - ../../../_internal/shared/model/data_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + gene: Nuclei + target: nucleus + target_id: nucleus + train_set: a549_mantis + model_name: celldiff_2d + experiment_id: nucleus__a549_mantis__celldiff_2d + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered non-focus store. + dataset_ref: null + +data: + init_args: + # pooled dual nucl+memb in-focus slab store (Nuclei channel) — resolver disabled above. + source_channel: Phase3D + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + # Flatten the target fragment's [13, 624, 624] weighted crop to Z=1. + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [1, 624, 624] + num_samples: 2 + + +trainer: + logger: + init_args: + name: CELLDiff2D_A549_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/celldiff_2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + every_n_epochs: 1 + save_top_k: -1 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/celldiff_2d/checkpoints + +launcher: + job_name: CELLDiff2D_A549_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/celldiff_2d + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D + # store (~1/4 the Z), so the 512G headroom the 3D leaf needed for + # mmap_preload is wasteful and delays scheduling. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..9d892bedf --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# CellDiff-2D predict: nucleus trained on ipsc_confocal, tested on a549-mantis-h2b-denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv + model_name: celldiff_2d + experiment_id: nucleus__ipsc_confocal__celldiff_2d__a549_mantis_h2b_denv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_denv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_2d/checkpoints/epoch=19-step=20000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..57e53ae62 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# CellDiff-2D predict: nucleus trained on ipsc_confocal, tested on a549-mantis-h2b-mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock + model_name: celldiff_2d + experiment_id: nucleus__ipsc_confocal__celldiff_2d__a549_mantis_h2b_mock + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_mock. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_2d/checkpoints/epoch=19-step=20000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..b6df848ad --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# CellDiff-2D predict: nucleus trained on ipsc_confocal, tested on a549-mantis-h2b-zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv + model_name: celldiff_2d + experiment_id: nucleus__ipsc_confocal__celldiff_2d__a549_mantis_h2b_zikv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_zikv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_2d/checkpoints/epoch=19-step=20000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..d2912b6c0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: nucleus trained on ipsc_confocal, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: celldiff_2d + experiment_id: nucleus__ipsc_confocal__celldiff_2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_2d/checkpoints/epoch=19-step=20000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/ipsc/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_NUCL_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/train.yml new file mode 100644 index 000000000..77a086004 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/train.yml @@ -0,0 +1,82 @@ +# CellDiff-2D (CELLDiffNet run Z-preserving at Z=1) fit on nucleus (Nuclei +# channel) — ipsc_confocal, in-focus 2D track. Mirror of the 3D +# nucleus/celldiff/ipsc_confocal fit leaf, flattened onto the offline +# 5-plane in-focus slab store (z_window_size=1 emits one in-focus window +# per plane). +# +# The 3D leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus store. +# The 2D track reads the `_focus.zarr` slab instead, so the resolver is +# disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field +# co-declared with a full dataset_ref. +# +# The train_set fragment supplies data.class_path (HCSDataModule) plus +# split_ratio / mmap_preload / scratch_dir — without it the resolved +# config has an init_args-only data block and `dynacell fit` fails to +# build the datamodule. targets/nucleus_celldiff.yml supplies the +# MinMaxSampled(timepoint_statistics) normalization CellDiff needs +# (p1/p99 -> [-1,1], not mean/std); only its RandWeightedCropd is +# list-replaced below, flattened [13,624,624] -> [1,624,624]. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus_celldiff.yml + - ../../../_internal/shared/model/data_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + gene: Nuclei + target: nucleus + target_id: nucleus + train_set: ipsc_confocal + model_name: celldiff_2d + experiment_id: nucleus__ipsc_confocal__celldiff_2d + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered non-focus store. + dataset_ref: null + +data: + init_args: + # aics-hipsc multi-marker in-focus slab store (Nuclei channel) — resolver disabled above. + source_channel: Phase3D + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + # Flatten the target fragment's [13, 624, 624] weighted crop to Z=1. + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [1, 624, 624] + num_samples: 2 + + +trainer: + logger: + init_args: + name: CELLDiff2D_iPSC_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + every_n_epochs: 1 + save_top_k: -1 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_2d/checkpoints + +launcher: + job_name: CELLDiff2D_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_2d + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D + # store (~1/4 the Z), so the 512G headroom the 3D leaf needed for + # mmap_preload is wasteful and delays scheduling. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/train_smoke.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/train_smoke.yml new file mode 100644 index 000000000..f6c68465c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/ipsc_confocal/train_smoke.yml @@ -0,0 +1,67 @@ +# Smoke sibling of nucleus/celldiff_2d/ipsc_confocal/train.yml. +# Proves the CellDiff-2D stack is trainable before twelve multi-day fits launch: +# that CELLDiffNet builds at input_spatial_size [1,512,512] with the per-axis +# patch [1,4,4] (a cubic patch cannot consume a size-1 Z axis), that the +# in-focus slab store feeds z_window_size=1 windows through +# RandWeightedCropd[1,624,624] -> affine -> center-crop[1,512,512] at the exact +# size the fixed ViT positional embeddings require, and that train + val +# forward/backward give a finite flow-matching loss under bf16-mixed. +# +# Scratch run_root, no logger, no checkpoints (so no junk last.ckpt can shadow +# the real run), 20 steps, bounded wall. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus_celldiff.yml + - ../../../_internal/shared/model/data_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + - ../../../_internal/shared/model/launcher_profiles/wall_smoke.yml + +benchmark: + task: virtual_staining + organelle: nucleus + gene: Nuclei + target: nucleus + target_id: nucleus + train_set: ipsc_confocal + model_name: celldiff_2d + experiment_id: nucleus__ipsc_confocal__celldiff_2d__smoke + dataset_ref: null + +data: + init_args: + source_channel: Phase3D + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Nuclei] + level: timepoint_statistics + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [1, 624, 624] + num_samples: 2 + +trainer: + max_steps: 20 + max_epochs: 1 + limit_val_batches: 2 + logger: false + enable_checkpointing: false + callbacks: [] + +launcher: + job_name: CELLDiff2D_NUCL_SMOKE + run_root: /hpc/mydata/alex.kalinin/VisCy/.tmp/celldiff2d_smoke + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..93b7d1f6f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,59 @@ +# CellDiff-2D predict: nucleus trained on joint_ipsc_confocal_a549_mantis, tested on a549-mantis-h2b-denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_denv + model_name: celldiff_2d + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__celldiff_2d__a549_mantis_h2b_denv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_denv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/celldiff_2d/checkpoints/epoch=19-step=32000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/a549__denv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_JOINT_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..e7832dfef --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,59 @@ +# CellDiff-2D predict: nucleus trained on joint_ipsc_confocal_a549_mantis, tested on a549-mantis-h2b-mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_mock + model_name: celldiff_2d + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__celldiff_2d__a549_mantis_h2b_mock + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_mock. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/celldiff_2d/checkpoints/epoch=19-step=32000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/a549__mock/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_JOINT_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..14a28b9cc --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,59 @@ +# CellDiff-2D predict: nucleus trained on joint_ipsc_confocal_a549_mantis, tested on a549-mantis-h2b-zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_zikv + model_name: celldiff_2d + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__celldiff_2d__a549_mantis_h2b_zikv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_zikv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/celldiff_2d/checkpoints/epoch=19-step=32000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/a549__zikv/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_JOINT_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..1bf5a2a3b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,55 @@ +# CellDiff-2D predict: nucleus trained on joint_ipsc_confocal_a549_mantis, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (celldiff_2d_predict overlay), emitting one +# window per z-plane -> a full-extent prediction store the existing focus-aware +# eval consumes unchanged. +# +# Source normalization is MinMaxSampled(timepoint_statistics), reproducing +# the CellDiff-2D fit exactly — CellDiff trains on p1/p99 -> [-1,1], and a +# mean/std source here would silently degrade every prediction. +# +# predict_overlap Z is 0 (see the overlay): the Z patch is 1, and +# window_starts requires 0 <= overlap < patch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: celldiff_2d + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__celldiff_2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/celldiff_2d/checkpoints/epoch=19-step=32000.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/ipsc/prediction.zarr + +launcher: + job_name: CELLDiff2D_PRED_JOINT_NUCL_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..351abc343 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,138 @@ +# CellDiff-2D (CELLDiffNet run Z-preserving at Z=1) fit on nucleus (Nuclei) +# — joint ipsc_confocal + a549_mantis pooled, in-focus 2D track. Mirror of +# the 3D nucleus/celldiff/joint_* fit leaf, flattened onto the offline +# 5-plane in-focus slab stores. +# +# BatchedConcatDataModule + two explicit HCSDataModule children; only +# model_overlays/celldiff_2d_fit.yml is composed (the data block is +# authored inline here, not via data_overlays). +# +# batch_size 2 here, NOT the single-set 4: BatchedConcatDataModule's +# train_dataloader uses batch_size as-is, while HCSDataModule divides by +# RandWeightedCropd num_samples. 2 indices * 2 num_samples = 4 GPU +# samples, matching the single-set leaves. +base: + - ../../../_internal/shared/model/model_overlays/celldiff_2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + gene: Nuclei + target: nucleus + target_id: nucleus + train_set: joint_ipsc_confocal_a549_mantis + model_name: celldiff_2d + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__celldiff_2d + +trainer: + logger: + init_args: + name: CELLDiff2D_JOINT_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/celldiff_2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + every_n_epochs: 1 + save_top_k: -1 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/celldiff_2d/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Nuclei + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: [512, 512] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Phase3D] + level: timepoint_statistics + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: [Nuclei] + level: timepoint_statistics + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [1, 624, 624] + num_samples: 2 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [0, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[1, 1], [0.5, 1.5], [0.5, 1.5]] + safe_crop_size: [1, 512, 512] + safe_crop_coverage: 0.9 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0, 0] + val_gpu_augmentations: + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] + + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc multi-marker in-focus slab store (Nuclei channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + # a549_mantis — pooled dual nucl+memb in-focus slab store (Nuclei channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + +launcher: + job_name: CELLDiff2D_JOINT_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/celldiff_2d + # 128G: both children preload 5-plane in-focus slabs (~1/4 the Z of the + # 3D stores), so the 512G the 3D joint leaf needed is wasteful here. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..da5a018a2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,43 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf nucleus/celldiff_2d/ipsc_confocal/predict__a549_mantis_denv.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv + model_name: celldiff_2d_seed1 + experiment_id: nucleus__ipsc_confocal__celldiff_2d_seed1__a549_mantis_h2b_denv + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_2d_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d_seed1/ipsc/a549__denv/prediction.zarr +launcher: + job_name: CELLDiff2D_PRED_NUCL_ON_A549_DENV_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d_seed1/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..96d516b63 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,43 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf nucleus/celldiff_2d/ipsc_confocal/predict__a549_mantis_mock.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock + model_name: celldiff_2d_seed1 + experiment_id: nucleus__ipsc_confocal__celldiff_2d_seed1__a549_mantis_h2b_mock + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_2d_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d_seed1/ipsc/a549__mock/prediction.zarr +launcher: + job_name: CELLDiff2D_PRED_NUCL_ON_A549_MOCK_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d_seed1/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..210a42a03 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,43 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf nucleus/celldiff_2d/ipsc_confocal/predict__a549_mantis_zikv.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv + model_name: celldiff_2d_seed1 + experiment_id: nucleus__ipsc_confocal__celldiff_2d_seed1__a549_mantis_h2b_zikv + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_2d_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d_seed1/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: CELLDiff2D_PRED_NUCL_ON_A549_ZIKV_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d_seed1/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..6f8629603 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,41 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf nucleus/celldiff_2d/ipsc_confocal/predict__ipsc_confocal.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/celldiff_2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_celldiff.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: celldiff_2d_seed1 + experiment_id: nucleus__ipsc_confocal__celldiff_2d_seed1__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_2d_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.MinMaxSampled + init_args: + keys: + - Phase3D + level: timepoint_statistics + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d_seed1/ipsc/ipsc/prediction.zarr +launcher: + job_name: CELLDiff2D_PRED_NUCL_ON_IPSC_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/celldiff_2d_seed1/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/train.yml new file mode 100644 index 000000000..af26b2cd9 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/celldiff_2d_seed1/ipsc_confocal/train.yml @@ -0,0 +1,61 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (fit) of the baseline leaf nucleus/celldiff_2d/ipsc_confocal/train.yml. +# Recipe delta vs that leaf: seed_everything: 1. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/train_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/nucleus_celldiff.yml +- ../../../_internal/shared/model/data_overlays/celldiff_2d_fit.yml +- ../../../_internal/shared/model/model_overlays/celldiff_2d_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + gene: Nuclei + target: nucleus + target_id: nucleus + train_set: ipsc_confocal + model_name: celldiff_2d_seed1 + experiment_id: nucleus__ipsc_confocal__celldiff_2d_seed1 + dataset_ref: null +data: + init_args: + source_channel: Phase3D + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Nuclei + w_key: Nuclei + spatial_size: + - 1 + - 624 + - 624 + num_samples: 2 +trainer: + logger: + init_args: + name: CELLDiff2D_iPSC_NUCL_seed1 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_2d_seed1 + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + every_n_epochs: 1 + save_top_k: -1 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_2d_seed1/checkpoints +launcher: + job_name: CELLDiff2D_NUCL_seed1 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/celldiff_2d_seed1 + sbatch: + mem: 128G +seed_everything: 1 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..dc4cf2486 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: nucleus trained on a549_mantis, +# tested on a549-mantis-h2b-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_denv + model_name: fcmae_vscyto2d_pretrained + experiment_id: nucleus__a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_h2b_denv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_denv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto2d_pretrained/checkpoints/epoch=31-step=9600-loss=1.167.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_A549TR_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..2c651b466 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: nucleus trained on a549_mantis, +# tested on a549-mantis-h2b-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_mock + model_name: fcmae_vscyto2d_pretrained + experiment_id: nucleus__a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_h2b_mock + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_mock. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto2d_pretrained/checkpoints/epoch=31-step=9600-loss=1.167.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_A549TR_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..6e0479ed9 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: nucleus trained on a549_mantis, +# tested on a549-mantis-h2b-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_zikv + model_name: fcmae_vscyto2d_pretrained + experiment_id: nucleus__a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_h2b_zikv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_zikv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto2d_pretrained/checkpoints/epoch=31-step=9600-loss=1.167.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_A549TR_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..09350a8ad --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: nucleus trained on a549_mantis, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_pretrained + experiment_id: nucleus__a549_mantis__fcmae_vscyto2d_pretrained__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto2d_pretrained/checkpoints/epoch=31-step=9600-loss=1.167.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_A549TR_NUCL_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/train.yml new file mode 100644 index 000000000..a0688fd67 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/a549_mantis/train.yml @@ -0,0 +1,85 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) with FCMAE-2D +# pretrained encoder init on nucleus (Nuclei marker), in-focus 2D +# benchmark track, A549 mantis pooled (mock + DENV + ZIKV). Paper key: +# VSCyto2D. Companion to fcmae_vscyto2d_scratch — the two leaves are +# identical except this one loads the 2D FCMAE encoder weights and drops +# lr to 0.0002 (mirroring cytoland VSCyto2D finetuning). +# +# Reads the offline 5-plane in-focus slab store dual_nucl_memb_all_focus.zarr +# (extracted from the 3D dual_nucl_memb_all.zarr; z_window_size=1 emits one +# in-focus window per plane). Mirror of the 3D +# nucleus/fcmae_vscyto3d_pretrained/a549_mantis fit leaf. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: a549_mantis + model_name: fcmae_vscyto2d_pretrained + experiment_id: nucleus__a549_mantis__fcmae_vscyto2d_pretrained + +# Override the FCMAE-2D data overlay's hardcoded `Structure` augmentation +# keys (the overlay was authored for ER/Mito where target_channel == +# "Structure"). RandWeightedCropd needs the actual nucleus channel name in +# keys/w_key. spatial_size + num_samples kept identical to the FCMAE-2D +# overlay so the augmentation policy matches ER/Mito. +data: + init_args: + # A549 pooled in-focus slab store + target_channel — no resolver in + # this train_set. Nucleus + membrane share dual_nucl_memb_all_focus.zarr + # (the membrane 2D leaf re-keys to Membrane). + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [1, 600, 600] + num_samples: 4 + +model: + init_args: + # Load only the encoder from the 2D FCMAE ckpt (400 ep on HEK + A549 + + # BJ5a + LIVECell + CTMC phase data); decoder/head stay at fresh init. + # lr 0.0002 overrides the overlay's 0.0004 for pretrained finetuning. + encoder_only: true + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/fcmae-2d/pretrain-logs/hek-a549-bj5a-livecell-ctmc-400ep/checkpoints/last.ckpt + lr: 0.0002 + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Pretrained_A549_Nucleus + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto2d_pretrained + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto2d_pretrained/checkpoints + +launcher: + job_name: FCMAE_VSCyto2D_Pretrained_A549_Nucleus + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto2d_pretrained + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..9e7b59959 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: nucleus trained on ipsc_confocal, +# tested on a549-mantis-h2b-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv + model_name: fcmae_vscyto2d_pretrained + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_pretrained__a549_mantis_h2b_denv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_denv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_pretrained/checkpoints/epoch=17-step=9000-loss=0.491.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..e4058c5b9 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: nucleus trained on ipsc_confocal, +# tested on a549-mantis-h2b-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock + model_name: fcmae_vscyto2d_pretrained + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_pretrained__a549_mantis_h2b_mock + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_mock. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_pretrained/checkpoints/epoch=17-step=9000-loss=0.491.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..f79215cdc --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: nucleus trained on ipsc_confocal, +# tested on a549-mantis-h2b-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv + model_name: fcmae_vscyto2d_pretrained + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_pretrained__a549_mantis_h2b_zikv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_zikv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_pretrained/checkpoints/epoch=17-step=9000-loss=0.491.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..1b24c99a1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: nucleus trained on ipsc_confocal, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_pretrained + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_pretrained__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_pretrained/checkpoints/epoch=17-step=9000-loss=0.491.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_NUCL_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/train.yml new file mode 100644 index 000000000..8dca27c0d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal/train.yml @@ -0,0 +1,93 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) with FCMAE-2D +# pretrained encoder init on nucleus (Nuclei marker), in-focus 2D +# benchmark track, iPSC confocal (aics-hipsc). Paper key: VSCyto2D. +# Companion to fcmae_vscyto2d_scratch — the two leaves are identical +# except this one loads the 2D FCMAE encoder weights and drops lr to +# 0.0002 (mirroring cytoland VSCyto2D finetuning). +# +# The 3D ipsc leaf resolves data_path/source_channel/target_channel from +# the manifest via benchmark.dataset_ref, which points at the NON-focus +# cell.zarr. The 2D track reads the offline 5-plane in-focus slab store +# cell_focus.zarr instead, so the resolver is disabled here +# (dataset_ref: null) and the three data fields are declared inline — the +# resolver hook raises on any data.init_args field co-declared with a full +# dataset_ref. source_channel/target_channel reproduce the resolver's +# manifest output (Phase3D / Nuclei). Mirror of the 3D +# nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal fit leaf. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: ipsc_confocal + model_name: fcmae_vscyto2d_pretrained + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_pretrained + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered cell.zarr. dataset_ref: null makes + # the compose hook a no-op so data fields can be declared inline. + dataset_ref: null + +# Override the FCMAE-2D data overlay's hardcoded `Structure` augmentation +# keys (the overlay was authored for ER/Mito where target_channel == +# "Structure"). RandWeightedCropd needs the actual nucleus channel name in +# keys/w_key. spatial_size + num_samples kept identical to the FCMAE-2D +# overlay so the augmentation policy matches ER/Mito. +data: + init_args: + # iPSC in-focus slab store + channels — resolver disabled above. + source_channel: Phase3D + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [1, 600, 600] + num_samples: 4 + +model: + init_args: + # Load only the encoder from the 2D FCMAE ckpt (400 ep on HEK + A549 + + # BJ5a + LIVECell + CTMC phase data); decoder/head stay at fresh init. + # lr 0.0002 overrides the overlay's 0.0004 for pretrained finetuning. + encoder_only: true + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/fcmae-2d/pretrain-logs/hek-a549-bj5a-livecell-ctmc-400ep/checkpoints/last.ckpt + lr: 0.0002 + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Pretrained_iPSC_Nucleus + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_pretrained + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_pretrained/checkpoints + +launcher: + job_name: FCMAE_VSCyto2D_Pretrained_Nucleus + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_pretrained + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..cafa0f426 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: nucleus trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-h2b-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_denv + model_name: fcmae_vscyto2d_pretrained + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_h2b_denv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_denv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto2d_pretrained/checkpoints/epoch=77-step=62400-loss=0.678.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_JOINT_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..953d537dd --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: nucleus trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-h2b-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_mock + model_name: fcmae_vscyto2d_pretrained + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_h2b_mock + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_mock. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto2d_pretrained/checkpoints/epoch=77-step=62400-loss=0.678.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_JOINT_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..2e853a65e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: nucleus trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-h2b-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_zikv + model_name: fcmae_vscyto2d_pretrained + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained__a549_mantis_h2b_zikv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_zikv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto2d_pretrained/checkpoints/epoch=77-step=62400-loss=0.678.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_JOINT_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..fedcd3247 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Pretrained (VSCyto2D) predict: nucleus trained on joint_ipsc_confocal_a549_mantis, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_pretrained + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto2d_pretrained/checkpoints/epoch=77-step=62400-loss=0.678.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Pretrained_PRED_JOINT_NUCL_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_pretrained/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..a57863eb0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,165 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) with FCMAE-2D +# pretrained encoder init on nucleus (NUCL) — joint +# ipsc_confocal + a549_mantis pooled, in-focus 2D benchmark track. +# Paper key: VSCyto2D. Companion to the fcmae_vscyto2d_scratch joint +# leaf — the two are identical except this one loads the 2D FCMAE +# encoder weights and drops lr to 0.0002 (mirroring cytoland VSCyto2D +# finetuning). Mirrors nucleus/fcmae_vscyto2d_pretrained/ipsc_confocal +# on the joint train_set, flattened to the 2D focus-slab geometry. +# +# Joint leaf: BatchedConcatDataModule with two explicit HCSDataModule +# children (no benchmark.dataset_ref — joint leaves bypass the single- +# dataset resolver, so both child data_paths are the offline +# `_focus.zarr` slab stores directly). Only +# model_overlays/fcmae_vscyto2d_fit.yml is composed; the data block is +# authored inline because joint hparams live on the children. +# +# Topology: single-GPU (inherited from model_overlays/fcmae_vscyto2d_fit.yml +# single_gpu base). z_window_size=1 reads one in-focus plane per window; +# BatchedConcatDataModule does NOT divide batch_size by num_samples, so +# batch_size=4 * num_samples=4 = 16 GPU samples/step, matching the +# single-set 2D data overlay's effective 16. +base: + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + gene: Nuclei + target: nucleus + target_id: nucleus + train_set: joint_ipsc_confocal_a549_mantis + model_name: fcmae_vscyto2d_pretrained + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_pretrained + +model: + init_args: + # Load only the encoder from the 2D FCMAE ckpt (400 ep on HEK + A549 + + # BJ5a + LIVECell + CTMC phase data); decoder/head stay at fresh init. + # lr 0.0002 overrides the overlay's 0.0004 for pretrained finetuning. + encoder_only: true + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/fcmae-2d/pretrain-logs/hek-a549-bj5a-livecell-ctmc-400ep/checkpoints/last.ckpt + lr: 0.0002 + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Pretrained_JOINT_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto2d_pretrained + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto2d_pretrained/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Nuclei + z_window_size: 1 + # batch_size is NOT divided by num_samples in joint mode: 4 indices * + # num_samples=4 = 16 GPU samples per rank, matching the single-set 2D + # data overlay's effective 16. + batch_size: 4 + num_workers: 4 + yx_patch_size: [384, 384] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Nuclei] + level: fov_statistics + subtrahend: median + divisor: iqr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [1, 600, 600] + num_samples: 4 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [0, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[1, 1], [0.5, 1.5], [0.5, 1.5]] + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 384, 384] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0, 0] + val_gpu_augmentations: + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 384, 384] + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc multi-marker in-focus slab (Nuclei channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + # a549_mantis — pooled dual nucl+memb in-focus slab (Nuclei channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + +launcher: + job_name: FCMAE_VSCyto2D_Pretrained_JOINT_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto2d_pretrained + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..f30c9e991 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: nucleus trained on a549_mantis, +# tested on a549-mantis-h2b-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_denv + model_name: fcmae_vscyto2d_scratch + experiment_id: nucleus__a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_h2b_denv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_denv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto2d_scratch/checkpoints/epoch=89-step=27000-loss=1.213.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_A549TR_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..1fca214e7 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: nucleus trained on a549_mantis, +# tested on a549-mantis-h2b-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_mock + model_name: fcmae_vscyto2d_scratch + experiment_id: nucleus__a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_h2b_mock + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_mock. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto2d_scratch/checkpoints/epoch=89-step=27000-loss=1.213.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_A549TR_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..b235306bc --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: nucleus trained on a549_mantis, +# tested on a549-mantis-h2b-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_zikv + model_name: fcmae_vscyto2d_scratch + experiment_id: nucleus__a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_h2b_zikv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_zikv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto2d_scratch/checkpoints/epoch=89-step=27000-loss=1.213.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_A549TR_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..261df706e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: nucleus trained on a549_mantis, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch + experiment_id: nucleus__a549_mantis__fcmae_vscyto2d_scratch__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto2d_scratch/checkpoints/epoch=89-step=27000-loss=1.213.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_A549TR_NUCL_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/train.yml new file mode 100644 index 000000000..a2945425c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/a549_mantis/train.yml @@ -0,0 +1,75 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) random-init baseline +# on nucleus (Nuclei marker), in-focus 2D benchmark track, A549 mantis +# pooled (mock + DENV + ZIKV). Paper key: UNeXt2-2D. Scratch control for +# the fcmae_vscyto2d_pretrained (VSCyto2D) counterpart — the two leaves +# are identical except this one does NOT load pretrained encoder weights. +# +# Reads the offline 5-plane in-focus slab store dual_nucl_memb_all_focus.zarr +# (extracted from the 3D dual_nucl_memb_all.zarr; z_window_size=1 emits one +# in-focus window per plane). Mirror of the 3D +# nucleus/fcmae_vscyto3d_scratch/a549_mantis fit leaf. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: a549_mantis + model_name: fcmae_vscyto2d_scratch + experiment_id: nucleus__a549_mantis__fcmae_vscyto2d_scratch + +# Override the FCMAE-2D data overlay's hardcoded `Structure` augmentation +# keys (the overlay was authored for ER/Mito where target_channel == +# "Structure"). RandWeightedCropd needs the actual nucleus channel name in +# keys/w_key. spatial_size + num_samples kept identical to the FCMAE-2D +# overlay so the augmentation policy matches ER/Mito. +data: + init_args: + # A549 pooled in-focus slab store + target_channel — no resolver in + # this train_set. Nucleus + membrane share dual_nucl_memb_all_focus.zarr + # (the membrane 2D leaf re-keys to Membrane). + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [1, 600, 600] + num_samples: 4 + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Scratch_A549_Nucleus + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto2d_scratch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto2d_scratch/checkpoints + +launcher: + job_name: FCMAE_VSCyto2D_Scratch_A549_Nucleus + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto2d_scratch + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..4bd035427 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: nucleus trained on ipsc_confocal, +# tested on a549-mantis-h2b-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv + model_name: fcmae_vscyto2d_scratch + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_scratch__a549_mantis_h2b_denv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_denv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch/checkpoints/epoch=26-step=13500-loss=0.506.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..c1aa41ab2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: nucleus trained on ipsc_confocal, +# tested on a549-mantis-h2b-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock + model_name: fcmae_vscyto2d_scratch + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_scratch__a549_mantis_h2b_mock + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_mock. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch/checkpoints/epoch=26-step=13500-loss=0.506.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..7639141e7 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: nucleus trained on ipsc_confocal, +# tested on a549-mantis-h2b-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv + model_name: fcmae_vscyto2d_scratch + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_scratch__a549_mantis_h2b_zikv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_zikv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch/checkpoints/epoch=26-step=13500-loss=0.506.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..e5c2c9c95 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: nucleus trained on ipsc_confocal, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_scratch__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch/checkpoints/epoch=26-step=13500-loss=0.506.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_NUCL_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml new file mode 100644 index 000000000..75ae88590 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml @@ -0,0 +1,83 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) random-init baseline +# on nucleus (Nuclei marker), in-focus 2D benchmark track, iPSC confocal. +# Scratch control for the fcmae_vscyto2d_pretrained (VSCyto2D) counterpart +# — the two leaves are identical except this one does NOT load pretrained +# encoder weights. Mirror of the 3D +# nucleus/fcmae_vscyto3d_scratch/ipsc_confocal fit leaf. +# +# The 3D ipsc leaf resolves data_path/source_channel/target_channel from +# the manifest via benchmark.dataset_ref, which points at the NON-focus +# cell.zarr. The 2D track reads the offline 5-plane in-focus slab store +# cell_focus.zarr instead, so the resolver is disabled here +# (dataset_ref: null) and the three data fields are declared inline — +# the resolver hook raises on any data.init_args field co-declared with a +# full dataset_ref. source_channel/target_channel reproduce the resolver's +# manifest output (Phase3D / Nuclei). +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_scratch + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered cell.zarr. dataset_ref: null makes + # the compose hook a no-op so data fields can be declared inline. + dataset_ref: null + +# Override the FCMAE-2D data overlay's hardcoded `Structure` augmentation +# keys (the overlay was authored for ER/Mito where target_channel == +# "Structure"). RandWeightedCropd needs the actual nucleus channel name in +# keys/w_key. spatial_size + num_samples kept identical to the FCMAE-2D +# overlay so the augmentation policy matches ER/Mito. +data: + init_args: + # iPSC in-focus slab store + channels — resolver disabled above. + source_channel: Phase3D + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [1, 600, 600] + num_samples: 4 + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Scratch_iPSC_Nucleus + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch/checkpoints + +launcher: + job_name: FCMAE_VSCyto2D_Scratch_Nucleus + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..d3c7f8c23 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: nucleus trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-h2b-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_denv + model_name: fcmae_vscyto2d_scratch + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_h2b_denv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_denv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto2d_scratch/checkpoints/epoch=50-step=40800-loss=0.711.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_JOINT_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..3d326c886 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: nucleus trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-h2b-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_mock + model_name: fcmae_vscyto2d_scratch + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_h2b_mock + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_mock. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto2d_scratch/checkpoints/epoch=50-step=40800-loss=0.711.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_JOINT_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..32f4d98ec --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,63 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: nucleus trained on joint_ipsc_confocal_a549_mantis, +# tested on a549-mantis-h2b-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_zikv + model_name: fcmae_vscyto2d_scratch + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch__a549_mantis_h2b_zikv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_zikv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto2d_scratch/checkpoints/epoch=50-step=40800-loss=0.711.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_JOINT_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..00e2705fd --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,59 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: nucleus trained on joint_ipsc_confocal_a549_mantis, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# ckpt_path pins the lowest-val-loss retained checkpoint of the +# 2026-08-01 revived fit (the earlier cohort froze at init under +# 16-mixed and its checkpoints are NOT usable). Submit with +# `--ckpt best` to re-resolve against the live best at submit time. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto2d_scratch/checkpoints/epoch=50-step=40800-loss=0.711.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_PRED_JOINT_NUCL_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..3b2f80b06 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,150 @@ +# FCMAE-2D (FullyConvolutionalMAE, pretraining=False) random-init baseline +# on nucleus (NUCL), in-focus 2D benchmark track — joint ipsc_confocal + +# a549_mantis pooled. Scratch control for the fcmae_vscyto2d_pretrained +# (VSCyto2D) counterpart — the two leaves are identical except this one +# does NOT load pretrained encoder weights. Mirrors +# nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml on the joint +# train_set and the 3D nucleus/fcmae_vscyto3d_scratch/joint_* leaf. +# +# Joint leaf: BatchedConcatDataModule + two explicit HCSDataModule +# children; only model_overlays/fcmae_vscyto2d_fit.yml is composed (the +# data overlay is NOT — the data block is inlined via the &hcs_init_args +# anchor). Both children read the offline 5-plane in-focus slab stores +# (z_window_size=1). Single-GPU topology (from the 2D model overlay + +# hardware_gpu_any_long), so no DDP block. +base: + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + gene: Nuclei + target: nucleus + target_id: nucleus + train_set: joint_ipsc_confocal_a549_mantis + model_name: fcmae_vscyto2d_scratch + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__fcmae_vscyto2d_scratch + +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Scratch_JOINT_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto2d_scratch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto2d_scratch/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Nuclei + z_window_size: 1 + # Joint mode does not divide batch_size by num_samples, so 4 * 4 = 16 GPU + # samples per step matches the single-set 2D overlay's effective batch + # (batch_size 16). Halved from the 3D joint's 8 to fit the single-GPU + # 48 GB pool (a40|l40s|a6000) that the 2D track targets. + batch_size: 4 + num_workers: 4 + yx_patch_size: [384, 384] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Nuclei] + level: fov_statistics + subtrahend: median + divisor: iqr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [1, 600, 600] + num_samples: 4 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [0, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[1, 1], [0.5, 1.5], [0.5, 1.5]] + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 384, 384] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0, 0] + val_gpu_augmentations: + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 384, 384] + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc multi-marker in-focus slab (Nuclei channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + # a549_mantis — pooled dual nucl/memb all-conditions in-focus slab (Nuclei channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + +launcher: + job_name: FCMAE_VSCyto2D_Scratch_JOINT_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto2d_scratch + # 5-plane focus stores put the dense mmap buffer at ~5-11 GiB, so the 256G in + # hardware_gpu_any_long.yml is inherited 3D scale and just queues slower. Set + # here, not in the model overlay: the hardware profile composes AFTER the + # overlay and would override it. (Applied live via scontrol 2026-07-23; a + # resubmit silently re-requested 256G until this was baked.) + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..ed517d2a1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,65 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: nucleus trained on ipsc_confocal, +# tested on a549-mantis-h2b-denv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# Sample-matched UNeXt2-2D ablation arm (fcmae_vscyto2d_scratch with the 3D fit's +# optimizer budget: 128 samples/step, warmup 8500, 3D cosine horizon); otherwise +# identical to the fcmae_vscyto2d_scratch leaf of the same name. +# ckpt_path is a PROVISIONAL pin: the fit is still running and save_top_k rotates +# files out. Submit with --ckpt best (uses only the parent dir), or re-bake after the +# fit completes (tools/bake_best_ckpt.py). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv + model_name: fcmae_vscyto2d_scratch_samplematched + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_scratch_samplematched__a549_mantis_h2b_denv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_denv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch_samplematched/checkpoints/epoch=4-step=310-loss=0.671.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_SampleMatch_PRED_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..dc8916d37 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,65 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: nucleus trained on ipsc_confocal, +# tested on a549-mantis-h2b-mock. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# Sample-matched UNeXt2-2D ablation arm (fcmae_vscyto2d_scratch with the 3D fit's +# optimizer budget: 128 samples/step, warmup 8500, 3D cosine horizon); otherwise +# identical to the fcmae_vscyto2d_scratch leaf of the same name. +# ckpt_path is a PROVISIONAL pin: the fit is still running and save_top_k rotates +# files out. Submit with --ckpt best (uses only the parent dir), or re-bake after the +# fit completes (tools/bake_best_ckpt.py). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock + model_name: fcmae_vscyto2d_scratch_samplematched + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_scratch_samplematched__a549_mantis_h2b_mock + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_mock. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch_samplematched/checkpoints/epoch=4-step=310-loss=0.671.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_SampleMatch_PRED_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..c8e3bfda8 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,65 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: nucleus trained on ipsc_confocal, +# tested on a549-mantis-h2b-zikv. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# Sample-matched UNeXt2-2D ablation arm (fcmae_vscyto2d_scratch with the 3D fit's +# optimizer budget: 128 samples/step, warmup 8500, 3D cosine horizon); otherwise +# identical to the fcmae_vscyto2d_scratch leaf of the same name. +# ckpt_path is a PROVISIONAL pin: the fit is still running and save_top_k rotates +# files out. Submit with --ckpt best (uses only the parent dir), or re-bake after the +# fit completes (tools/bake_best_ckpt.py). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv + model_name: fcmae_vscyto2d_scratch_samplematched + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_scratch_samplematched__a549_mantis_h2b_zikv + # A549 keys nucleus by gene (`h2b`); override the iPSC-side + # target_id so the resolver finds it on a549_mantis_h2b_zikv. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch_samplematched/checkpoints/epoch=4-step=310-loss=0.671.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_SampleMatch_PRED_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..b946a8e30 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,61 @@ +# FCMAE-2D Scratch (UNeXt2-2D) predict: nucleus trained on ipsc_confocal, +# tested on iPSC confocal. In-focus 2D track. Runs the 2D model over the +# full-Z 3D test store (z_window_size=1 -> one window per z-plane; +# the writer keys each output to its z-index) so the existing +# focus-aware eval consumes the result unchanged. +# +# Source normalization reproduces the fit overlay exactly +# (Phase3D fov_statistics mean/std); a mismatch here would +# silently degrade every prediction. +# +# Sample-matched UNeXt2-2D ablation arm (fcmae_vscyto2d_scratch with the 3D fit's +# optimizer budget: 128 samples/step, warmup 8500, 3D cosine horizon); otherwise +# identical to the fcmae_vscyto2d_scratch leaf of the same name. +# ckpt_path is a PROVISIONAL pin: the fit is still running and save_top_k rotates +# files out. Submit with --ckpt best (uses only the parent dir), or re-bake after the +# fit completes (tools/bake_best_ckpt.py). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch_samplematched + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_scratch_samplematched__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch_samplematched/checkpoints/epoch=4-step=310-loss=0.671.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/ipsc/prediction.zarr + +launcher: + job_name: FCMAE2D_Scratch_SampleMatch_PRED_NUCL_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/train.yml new file mode 100644 index 000000000..77a480ee8 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_samplematched/ipsc_confocal/train.yml @@ -0,0 +1,108 @@ +# Sample-matched UNeXt2-2D ablation — nucleus (Nuclei), iPSC-trained. +# +# IDENTICAL to nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml except the +# optimizer budget, which is copied from fcmae_vscyto3d_scratch (the 3D UNeXt2 it +# is compared against): +# - 4-GPU DDP x batch_size 32 per rank = 128 samples/step (was 1 GPU x 16) +# - warmup_steps 8500 (was 4000) +# - cosine horizon 62400 steps = the 3D fit's 200 epochs x 312 steps/epoch +# (WarmupCosine t_total = trainer.estimated_stepping_batches, capped here by +# max_steps; max_epochs is raised only so it never binds first) +# - validation + checkpoint cadence every 5 epochs x ~63 steps ~= 315 steps, +# close to the 3D fit's once per 312-step epoch, so best-val selection sees a +# similar number of candidates +# The 2D baseline trained 100000 steps x 16 samples = 1.6M samples; the 3D fit +# 43479 steps x 128 = 5.6M (it stopped at epoch 139/200; the paper predicts from +# its epoch=80-step=25272 checkpoint). This arm sees 62400 x 128 = 8.0M. +# +# Question it answers: after matching samples/step, steps and lr schedule, is +# the remaining 3D-vs-2D gap z-context, or was the 2D baseline under-trained? +# Target PLANES are NOT matched: each 3D sample supervises 15 planes, so the 3D +# fit still sees 15x the target planes per step. A plane-matched arm (batch 1920) +# is ~15x the compute and is deferred until this one reports. +# +# Precision stays bf16-mixed, deliberately NOT the 3D fit's 16-mixed: at depth 1, +# fp16's GradScaler silently skips NaN-gradient steps, which is how 24 FCMAE-2D +# fits reached epoch 199 with weights still at init (model_overlays/ +# fcmae_vscyto2d_fit.yml). Precision is a numerical format, not budget. +# +# DDP needs find_unused_parameters (FCMAE pretraining=False has decoder/head +# params unused on some paths) and the 3 h process-group timeout, both copied +# from model_overlays/fcmae_vscyto3d_fit.yml. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml + - ../../../../../recipes/topology/ddp_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch_samplematched + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_scratch_samplematched + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered cell.zarr. dataset_ref: null makes + # the compose hook a no-op so data fields can be declared inline. + dataset_ref: null + +data: + init_args: + # Per rank; x 4 ranks = 128 samples/step, the 3D fit's global batch. The + # overlay's 16 was sized for 48 GB cards (32 OOMs at ~47 GB there); + # hardware_4gpu.yml is H100/H200 only. + batch_size: 32 + # iPSC in-focus slab store + channels — resolver disabled above. + source_channel: Phase3D + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [1, 600, 600] + num_samples: 4 + +model: + init_args: + warmup_steps: 8500 + +trainer: + strategy: + class_path: lightning.pytorch.strategies.DDPStrategy + init_args: + find_unused_parameters: true + timeout: "3:00:00" + max_steps: 62400 + max_epochs: 2000 + check_val_every_n_epoch: 5 + logger: + init_args: + name: FCMAE_VSCyto2D_Scratch_SampleMatch_iPSC_Nucleus + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch_samplematched + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 5 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch_samplematched/checkpoints + +launcher: + job_name: FCMAE_VSCyto2D_Scratch_SampleMatch_Nucleus + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch_samplematched + # Same 128G as the 2D baseline: the focus store's mmap buffer is ~5-11 GiB, + # so hardware_4gpu.yml's 512G (sized for full-Z cell.zarr) only queues slower. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..968b3bb4f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,45 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv + model_name: fcmae_vscyto2d_scratch_seed1 + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_scratch_seed1__a549_mantis_h2b_denv + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/a549__denv/prediction.zarr +launcher: + job_name: FCMAE2D_Scratch_PRED_NUCL_ON_A549_DENV_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..6d502d3bf --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,45 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock + model_name: fcmae_vscyto2d_scratch_seed1 + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_scratch_seed1__a549_mantis_h2b_mock + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/a549__mock/prediction.zarr +launcher: + job_name: FCMAE2D_Scratch_PRED_NUCL_ON_A549_MOCK_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..d41fcc64b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,45 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv + model_name: fcmae_vscyto2d_scratch_seed1 + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_scratch_seed1__a549_mantis_h2b_zikv + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: FCMAE2D_Scratch_PRED_NUCL_ON_A549_ZIKV_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..a6051783b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,43 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/predict__ipsc_confocal.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch_seed1 + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_scratch_seed1__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/ipsc/prediction.zarr +launcher: + job_name: FCMAE2D_Scratch_PRED_NUCL_ON_IPSC_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/train.yml new file mode 100644 index 000000000..a45c33682 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto2d_scratch_seed1/ipsc_confocal/train.yml @@ -0,0 +1,61 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (fit) of the baseline leaf nucleus/fcmae_vscyto2d_scratch/ipsc_confocal/train.yml. +# Recipe delta vs that leaf: seed_everything: 1. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/train_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/data_overlays/fcmae_vscyto2d_fit.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto2d_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + train_set: ipsc_confocal + model_name: fcmae_vscyto2d_scratch_seed1 + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto2d_scratch_seed1 + dataset_ref: null +data: + init_args: + source_channel: Phase3D + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Nuclei + w_key: Nuclei + spatial_size: + - 1 + - 600 + - 600 + num_samples: 4 +trainer: + logger: + init_args: + name: FCMAE_VSCyto2D_Scratch_iPSC_Nucleus_seed1 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch_seed1 + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: epoch={epoch}-step={step}-loss={loss/validate:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 5 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch_seed1/checkpoints +launcher: + job_name: FCMAE_VSCyto2D_Scratch_Nucleus_seed1 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto2d_scratch_seed1 + sbatch: + mem: 128G +seed_everything: 1 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_denv.yml index f5f5388e6..2c9f04e1f 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_denv.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/nucleus.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_mock.yml index e75d9babf..ef0f7a85c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_mock.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/nucleus.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_zikv.yml index 454351568..2f488fcbe 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__a549_mantis_zikv.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/nucleus.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__ipsc_confocal.yml index 91da8959e..26143d78b 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/_no_train_randinit/predict__ipsc_confocal.yml @@ -7,7 +7,7 @@ base: - ../../../_internal/shared/model/targets/nucleus.yml - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_h200_single.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_h200.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml index 696fc353b..344db2aa1 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fcmae_vscyto3d_pretrained/checkpoints/epoch=134-step=29295.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=134-step=29295.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_a549trained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_A549TR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..8530000ec --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_denv_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: nucleus__a549_mantis__fcmae_vscyto3d_pretrained__a549_mantis_h2b_denv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=134-step=29295.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/a549/a549__denv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_A549TR_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml index 6f2be08e3..d0c039f82 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fcmae_vscyto3d_pretrained/checkpoints/epoch=134-step=29295.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=134-step=29295.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_a549trained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_A549TR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..04946f169 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_mock_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: nucleus__a549_mantis__fcmae_vscyto3d_pretrained__a549_mantis_h2b_mock__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=134-step=29295.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/a549/a549__mock/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_A549TR_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_movie.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_movie.yml new file mode 100644 index 000000000..bf73b0aec --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_movie.yml @@ -0,0 +1,47 @@ +# VSCyto3D predict: nucleus trained on a549_mantis, predicting on the +# cropped A549 TOMM20 DENV movie zarr (125 timepoints). +# No predict_set base — data path set directly to bypass the manifest system. +base: + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_movie + model_name: fcmae_vscyto3d_pretrained + experiment_id: nucleus__a549_mantis__fcmae_vscyto3d_pretrained__a549_mantis_movie + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=134-step=29295.ckpt + +data: + class_path: viscy_data.hcs.HCSDataModule + init_args: + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/movie/2024_11_21_A549_TOMM20_DENV_crop.zarr + source_channel: Phase3D + target_channel: Nucleus + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + z_window_size: 15 + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/a549/movie_predictions/nucl_fcmae_vscyto3d_pretrained_a549trained_movie.zarr + +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_A549TR_MOVIE + run_root: /hpc/projects/virtual_staining/training/dynacell/a549/movie_predictions diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml index 2f6e12b44..c512433a5 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fcmae_vscyto3d_pretrained/checkpoints/epoch=134-step=29295.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=134-step=29295.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_a549trained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_A549TR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..8f6da22c7 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_zikv_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: nucleus__a549_mantis__fcmae_vscyto3d_pretrained__a549_mantis_h2b_zikv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=134-step=29295.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/a549/a549__zikv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_A549TR_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml index feeb24517..e7462d3ac 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml @@ -19,7 +19,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fcmae_vscyto3d_pretrained/checkpoints/epoch=134-step=29295.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=134-step=29295.ckpt data: init_args: @@ -36,8 +36,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fcmae_vscyto3d_pretrained_a549trained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_A549TR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..667eeeda8 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: ipsc_confocal_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: nucleus__a549_mantis__fcmae_vscyto3d_pretrained__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=134-step=29295.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/a549/ipsc/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_A549TR_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/train.yml index 9d32fbce2..ea45fc64c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/a549_mantis/train.yml @@ -49,7 +49,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Pretrained_A549_Nucleus - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fcmae_vscyto3d_pretrained + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_pretrained callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -57,11 +57,13 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fcmae_vscyto3d_pretrained/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_pretrained/checkpoints launcher: job_name: FCMAE_VSCyto3D_Pretrained_A549_Nucleus - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fcmae_vscyto3d_pretrained + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_pretrained diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index 3b2336ac4..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Nucleus (H2B) predicted by FCMAE_VSCyto3D_Pretrained on a549-mantis-h2b-denv. -# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` -# target_id from the target group so the resolver finds h2b on a549-mantis-h2b-denv. -defaults: - - override /target: nucleus - - override /predict_set: a549_mantis_h2b_denv - -benchmark: - dataset_ref: - target: h2b - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_nucl_fcmae_vscyto3d_pretrained_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index 98538c332..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Nucleus (H2B) predicted by FCMAE_VSCyto3D_Pretrained on a549-mantis-h2b-mock. -# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` -# target_id from the target group so the resolver finds h2b on a549-mantis-h2b-mock. -defaults: - - override /target: nucleus - - override /predict_set: a549_mantis_h2b_mock - -benchmark: - dataset_ref: - target: h2b - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_nucl_fcmae_vscyto3d_pretrained_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index 01ceaec5f..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Nucleus (H2B) predicted by FCMAE_VSCyto3D_Pretrained on a549-mantis-h2b-zikv. -# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` -# target_id from the target group so the resolver finds h2b on a549-mantis-h2b-zikv. -defaults: - - override /target: nucleus - - override /predict_set: a549_mantis_h2b_zikv - -benchmark: - dataset_ref: - target: h2b - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_nucl_fcmae_vscyto3d_pretrained_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml index 16358821b..93f2875dd 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml @@ -28,7 +28,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fcmae_vscyto3d_pretrained/checkpoints/epoch=89-step=28080.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=89-step=28080.ckpt data: init_args: @@ -45,8 +45,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_ON_A549_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..f04223d4b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto3d_pretrained__a549_mantis_h2b_denv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=89-step=28080.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__denv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_ON_A549_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml index 5bd224569..33cf1ab99 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml @@ -28,7 +28,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fcmae_vscyto3d_pretrained/checkpoints/epoch=89-step=28080.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=89-step=28080.ckpt data: init_args: @@ -45,8 +45,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_ON_A549_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..45ddcb822 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto3d_pretrained__a549_mantis_h2b_mock__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=89-step=28080.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__mock/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_ON_A549_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml index 5b560e3eb..ee1aa59ef 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -28,7 +28,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fcmae_vscyto3d_pretrained/checkpoints/epoch=89-step=28080.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=89-step=28080.ckpt data: init_args: @@ -45,8 +45,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_ON_A549_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..179e5fb0c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto3d_pretrained__a549_mantis_h2b_zikv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=89-step=28080.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_ON_A549_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml index c5193febf..1afe3852a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml @@ -21,7 +21,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fcmae_vscyto3d_pretrained/checkpoints/epoch=89-step=28080.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=89-step=28080.ckpt data: init_args: @@ -38,8 +38,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fcmae_vscyto3d_pretrained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..eb1ce7eb8 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: fcmae_vscyto3d_pretrained + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto3d_pretrained__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=89-step=28080.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/ipsc/ipsc/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_pretrained/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/train.yml index fb8990970..525fd4b15 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/ipsc_confocal/train.yml @@ -46,7 +46,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Pretrained_iPSC_Nucleus - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fcmae_vscyto3d_pretrained + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_pretrained callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -54,11 +54,13 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fcmae_vscyto3d_pretrained/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_pretrained/checkpoints launcher: job_name: FCMAE_VSCyto3D_Pretrained_Nucleus - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fcmae_vscyto3d_pretrained + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_pretrained diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index 9ebddcc8d..3ba54f3ef 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -28,7 +28,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fcmae_vscyto3d_pretrained/checkpoints/epoch=62-step=33390.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=98-step=52470-loss=0.632.ckpt data: init_args: @@ -45,8 +45,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_jointtrained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_JOINTTR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index 738766e9d..358796d21 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -28,7 +28,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fcmae_vscyto3d_pretrained/checkpoints/epoch=62-step=33390.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=98-step=52470-loss=0.632.ckpt data: init_args: @@ -45,8 +45,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_jointtrained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_JOINTTR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index d51bdf76e..0c58bfca9 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -28,7 +28,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fcmae_vscyto3d_pretrained/checkpoints/epoch=62-step=33390.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=98-step=52470-loss=0.632.ckpt data: init_args: @@ -45,8 +45,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_pretrained_jointtrained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_JOINTTR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index 2b2e30090..49ca3299a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fcmae_vscyto3d_pretrained/checkpoints/epoch=62-step=33390.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto3d_pretrained/checkpoints/epoch=98-step=52470-loss=0.632.ckpt data: init_args: @@ -40,8 +40,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fcmae_vscyto3d_pretrained_jointtrained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Pretrained_PRED_NUCL_JOINTTR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_pretrained/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml index 32a7756ef..3cb31c1e4 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_pretrained/joint_ipsc_confocal_a549_mantis/train.yml @@ -22,7 +22,7 @@ base: - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_fit.yml - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu_long.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -46,7 +46,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Pretrained_JOINT_NUCL - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fcmae_vscyto3d_pretrained + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto3d_pretrained callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -54,10 +54,12 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fcmae_vscyto3d_pretrained/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto3d_pretrained/checkpoints _hcs_init_args: &hcs_init_args source_channel: Phase3D @@ -152,4 +154,4 @@ data: launcher: job_name: FCMAE_VSCyto3D_Pretrained_JOINT_NUCL - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fcmae_vscyto3d_pretrained + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto3d_pretrained diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml index ac0f1a961..2073d6d72 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fcmae_vscyto3d_scratch/checkpoints/epoch=110-step=24087.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=110-step=24087.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_a549trained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL_A549TR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..d5b47830e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_denv_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: nucleus__a549_mantis__fcmae_vscyto3d_scratch__a549_mantis_h2b_denv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=110-step=24087.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/a549/a549__denv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL_A549TR_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml index 35a05f078..2c7be2b46 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fcmae_vscyto3d_scratch/checkpoints/epoch=110-step=24087.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=110-step=24087.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_a549trained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL_A549TR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..174a0be20 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_mock_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: nucleus__a549_mantis__fcmae_vscyto3d_scratch__a549_mantis_h2b_mock__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=110-step=24087.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/a549/a549__mock/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL_A549TR_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml index 6542d8b3a..023f297fd 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fcmae_vscyto3d_scratch/checkpoints/epoch=110-step=24087.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=110-step=24087.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_a549trained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL_A549TR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..9e561e50b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_zikv_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: nucleus__a549_mantis__fcmae_vscyto3d_scratch__a549_mantis_h2b_zikv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=110-step=24087.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/a549/a549__zikv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL_A549TR_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml index e8b29d777..83481ac78 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml @@ -19,7 +19,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fcmae_vscyto3d_scratch/checkpoints/epoch=110-step=24087.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=110-step=24087.ckpt data: init_args: @@ -36,8 +36,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fcmae_vscyto3d_scratch_a549trained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL_A549TR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..ca57fbad6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: ipsc_confocal_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: nucleus__a549_mantis__fcmae_vscyto3d_scratch__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=110-step=24087.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/a549/ipsc/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL_A549TR_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/train.yml index 75cc6f2e3..46deff38e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/a549_mantis/train.yml @@ -41,7 +41,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Scratch_A549_Nucleus - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fcmae_vscyto3d_scratch + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_scratch callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -49,11 +49,13 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fcmae_vscyto3d_scratch/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_scratch/checkpoints launcher: job_name: FCMAE_VSCyto3D_Scratch_A549_Nucleus - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fcmae_vscyto3d_scratch + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fcmae_vscyto3d_scratch diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index 377bcd03b..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Nucleus (H2B) predicted by FCMAE_VSCyto3D_Scratch on a549-mantis-h2b-denv. -# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` -# target_id from the target group so the resolver finds h2b on a549-mantis-h2b-denv. -defaults: - - override /target: nucleus - - override /predict_set: a549_mantis_h2b_denv - -benchmark: - dataset_ref: - target: h2b - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_nucl_fcmae_vscyto3d_scratch_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index 29ddab61e..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Nucleus (H2B) predicted by FCMAE_VSCyto3D_Scratch on a549-mantis-h2b-mock. -# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` -# target_id from the target group so the resolver finds h2b on a549-mantis-h2b-mock. -defaults: - - override /target: nucleus - - override /predict_set: a549_mantis_h2b_mock - -benchmark: - dataset_ref: - target: h2b - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_nucl_fcmae_vscyto3d_scratch_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index 757a9cbd1..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Nucleus (H2B) predicted by FCMAE_VSCyto3D_Scratch on a549-mantis-h2b-zikv. -# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` -# target_id from the target group so the resolver finds h2b on a549-mantis-h2b-zikv. -defaults: - - override /target: nucleus - - override /predict_set: a549_mantis_h2b_zikv - -benchmark: - dataset_ref: - target: h2b - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_nucl_fcmae_vscyto3d_scratch_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml index 0ab3747e1..ff6500e46 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml @@ -35,7 +35,7 @@ model: # unless explicitly ablating against the scratch baseline. # Hardlink alias at run_root; underlying epoch=80-step=25272.ckpt also # preserved in checkpoints_frozen_ep80_/. - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fcmae_vscyto3d_scratch/best_ep80_val0.39342.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=80-step=25272.ckpt data: init_args: @@ -52,8 +52,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL_ON_A549_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..440b20e65 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto3d_scratch__a549_mantis_h2b_denv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=80-step=25272.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__denv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL_ON_A549_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml index 0c69a88e3..65d739616 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml @@ -35,7 +35,7 @@ model: # unless explicitly ablating against the scratch baseline. # Hardlink alias at run_root; underlying epoch=80-step=25272.ckpt also # preserved in checkpoints_frozen_ep80_/. - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fcmae_vscyto3d_scratch/best_ep80_val0.39342.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=80-step=25272.ckpt data: init_args: @@ -52,8 +52,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL_ON_A549_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..ffaf0bf83 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto3d_scratch__a549_mantis_h2b_mock__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=80-step=25272.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__mock/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL_ON_A549_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml index 3d506036c..b46eb441a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -35,7 +35,7 @@ model: # unless explicitly ablating against the scratch baseline. # Hardlink alias at run_root; underlying epoch=80-step=25272.ckpt also # preserved in checkpoints_frozen_ep80_/. - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fcmae_vscyto3d_scratch/best_ep80_val0.39342.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=80-step=25272.ckpt data: init_args: @@ -52,8 +52,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL_ON_A549_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..4f3ff0c30 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto3d_scratch__a549_mantis_h2b_zikv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=80-step=25272.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL_ON_A549_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml index 5f0034900..bf284d7db 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml @@ -28,7 +28,7 @@ model: # unless explicitly ablating against the scratch baseline. # Hardlink alias at run_root; underlying epoch=80-step=25272.ckpt also # preserved in checkpoints_frozen_ep80_/. - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fcmae_vscyto3d_scratch/best_ep80_val0.39342.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=80-step=25272.ckpt data: init_args: @@ -45,8 +45,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fcmae_vscyto3d_scratch.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..b1f2f1300 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: fcmae_vscyto3d_scratch + experiment_id: nucleus__ipsc_confocal__fcmae_vscyto3d_scratch__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=80-step=25272.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/ipsc/ipsc/prediction.zarr +launcher: + job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fcmae_vscyto3d_scratch/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/train.yml index 37687d096..e2064c6f2 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/ipsc_confocal/train.yml @@ -38,7 +38,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Scratch_iPSC_Nucleus - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fcmae_vscyto3d_scratch + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_scratch callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -46,11 +46,13 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fcmae_vscyto3d_scratch/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_scratch/checkpoints launcher: job_name: FCMAE_VSCyto3D_Scratch_Nucleus - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fcmae_vscyto3d_scratch + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fcmae_vscyto3d_scratch diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index af719c355..39bfe5f7c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fcmae_vscyto3d_scratch/checkpoints/epoch=92-step=49290.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=113-step=60420-loss=0.646.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_jointtrained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/a549__denv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL_JOINTTR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index f98b9b3f4..0cf6404cd 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fcmae_vscyto3d_scratch/checkpoints/epoch=92-step=49290.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=113-step=60420-loss=0.646.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_jointtrained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/a549__mock/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL_JOINTTR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index a4951adde..a889be132 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fcmae_vscyto3d_scratch/checkpoints/epoch=92-step=49290.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=113-step=60420-loss=0.646.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fcmae_vscyto3d_scratch_jointtrained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/a549__zikv/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL_JOINTTR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index d0e1d2766..4e008c1cb 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -21,7 +21,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fcmae_vscyto3d_scratch/checkpoints/epoch=92-step=49290.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto3d_scratch/checkpoints/epoch=113-step=60420-loss=0.646.ckpt data: init_args: @@ -38,8 +38,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fcmae_vscyto3d_scratch_jointtrained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/ipsc/prediction.zarr launcher: job_name: FCMAE_VSCyto3D_Scratch_PRED_NUCL_JOINTTR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fcmae_vscyto3d_scratch/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/train.yml index 5c78c67fa..776c866c9 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fcmae_vscyto3d_scratch/joint_ipsc_confocal_a549_mantis/train.yml @@ -17,7 +17,7 @@ base: - ../../../_internal/shared/model/model_overlays/fcmae_vscyto3d_fit.yml - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml - - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu_long.yml - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml benchmark: @@ -34,7 +34,7 @@ trainer: logger: init_args: name: FCMAE_VSCyto3D_Scratch_JOINT_NUCL - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fcmae_vscyto3d_scratch + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto3d_scratch callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -42,10 +42,12 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 5 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fcmae_vscyto3d_scratch/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto3d_scratch/checkpoints _hcs_init_args: &hcs_init_args source_channel: Phase3D @@ -139,4 +141,4 @@ data: launcher: job_name: FCMAE_VSCyto3D_Scratch_JOINT_NUCL - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fcmae_vscyto3d_scratch + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fcmae_vscyto3d_scratch diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..4ff95ac0a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,55 @@ +# FNet2D predict: nucleus (NUCL) trained on a549_mantis, tested on A549 mantis denv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=456-step=91400-loss=0.431.ckpt (loss/validate=0.431). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_denv + model_name: fnet2d + experiment_id: nucleus__a549_mantis__fnet2d__a549_mantis_h2b_denv + # Override the iPSC-side `nucleus` target with a549's gene-keyed `h2b`. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet2d/checkpoints/epoch=456-step=91400-loss=0.431.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__denv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_NUCL_A549TR_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..79b99af56 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,55 @@ +# FNet2D predict: nucleus (NUCL) trained on a549_mantis, tested on A549 mantis mock. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=456-step=91400-loss=0.431.ckpt (loss/validate=0.431). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_mock + model_name: fnet2d + experiment_id: nucleus__a549_mantis__fnet2d__a549_mantis_h2b_mock + # Override the iPSC-side `nucleus` target with a549's gene-keyed `h2b`. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet2d/checkpoints/epoch=456-step=91400-loss=0.431.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__mock/prediction.zarr + +launcher: + job_name: FNet2D_PRED_NUCL_A549TR_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..7babdbd37 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,55 @@ +# FNet2D predict: nucleus (NUCL) trained on a549_mantis, tested on A549 mantis zikv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=456-step=91400-loss=0.431.ckpt (loss/validate=0.431). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_zikv + model_name: fnet2d + experiment_id: nucleus__a549_mantis__fnet2d__a549_mantis_h2b_zikv + # Override the iPSC-side `nucleus` target with a549's gene-keyed `h2b`. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet2d/checkpoints/epoch=456-step=91400-loss=0.431.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__zikv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_NUCL_A549TR_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..caa7fb2b3 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,52 @@ +# FNet2D predict: nucleus (NUCL) trained on a549_mantis, tested on iPSC confocal. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=456-step=91400-loss=0.431.ckpt (loss/validate=0.431). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: fnet2d + experiment_id: nucleus__a549_mantis__fnet2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet2d/checkpoints/epoch=456-step=91400-loss=0.431.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/ipsc/prediction.zarr + +launcher: + job_name: FNet2D_PRED_NUCL_A549TR + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/train.yml new file mode 100644 index 000000000..bcf04c1c5 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/a549_mantis/train.yml @@ -0,0 +1,85 @@ +# FNet2D (FNet3D run Z-preserving at Z=1) fit on nucleus (Nuclei channel) — +# A549 mantis-lightsheet pooled (mock + DENV + ZIKV), in-focus 2D track. +# Mirror of the 3D nucleus/fnet3d_paper/a549_mantis fit leaf, flattened onto +# the offline 5-plane in-focus slab store dual_nucl_memb_all_focus.zarr +# (z_window_size=1 emits one in-focus window per plane). +# +# The fnet2d data overlay keys norm/aug/val_aug on Structure (the ER/Mito +# target). Nucleus target_channel is Nuclei, so we list-replace those three +# lists here to re-key them, flattening the crops [32,64,64] -> [1,64,64]. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: a549_mantis + model_name: fnet2d + experiment_id: nucleus__a549_mantis__fnet2d + +data: + init_args: + # A549 pooled in-focus slab store + target_channel — no resolver in this + # train_set. Nucleus + membrane share dual_nucl_memb_all_focus.zarr + # (the membrane 2D leaf re-keys to Membrane). + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Nuclei] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [1, 64, 64] + num_samples: 8 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Phase3D, Nuclei] + roi_size: [1, 64, 64] + +trainer: + logger: + init_args: + name: FNet2D_A549_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet2d/checkpoints + +launcher: + job_name: FNet2D_A549_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet2d + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D store + # (~1/4 the Z), so the 512G headroom the 3D leaf needed for mmap_preload + # is wasteful and delays scheduling. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..361172ed8 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,55 @@ +# FNet2D predict: nucleus (NUCL) trained on ipsc_confocal, tested on A549 mantis denv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=480-step=160173-loss=1.362.ckpt (loss/validate=1.362). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv + model_name: fnet2d + experiment_id: nucleus__ipsc_confocal__fnet2d__a549_mantis_h2b_denv + # Override the iPSC-side `nucleus` target with a549's gene-keyed `h2b`. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d/checkpoints/epoch=480-step=160173-loss=1.362.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_NUCL_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..9145d1532 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,55 @@ +# FNet2D predict: nucleus (NUCL) trained on ipsc_confocal, tested on A549 mantis mock. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=480-step=160173-loss=1.362.ckpt (loss/validate=1.362). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock + model_name: fnet2d + experiment_id: nucleus__ipsc_confocal__fnet2d__a549_mantis_h2b_mock + # Override the iPSC-side `nucleus` target with a549's gene-keyed `h2b`. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d/checkpoints/epoch=480-step=160173-loss=1.362.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: FNet2D_PRED_NUCL_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..bd1e2cf0f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,55 @@ +# FNet2D predict: nucleus (NUCL) trained on ipsc_confocal, tested on A549 mantis zikv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=480-step=160173-loss=1.362.ckpt (loss/validate=1.362). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv + model_name: fnet2d + experiment_id: nucleus__ipsc_confocal__fnet2d__a549_mantis_h2b_zikv + # Override the iPSC-side `nucleus` target with a549's gene-keyed `h2b`. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d/checkpoints/epoch=480-step=160173-loss=1.362.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_NUCL_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..7c390aeab --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,52 @@ +# FNet2D predict: nucleus (NUCL) trained on ipsc_confocal, tested on iPSC confocal. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=480-step=160173-loss=1.362.ckpt (loss/validate=1.362). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fnet2d + experiment_id: nucleus__ipsc_confocal__fnet2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d/checkpoints/epoch=480-step=160173-loss=1.362.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/ipsc/prediction.zarr + +launcher: + job_name: FNet2D_PRED_NUCL + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/train.yml new file mode 100644 index 000000000..14dff154b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/ipsc_confocal/train.yml @@ -0,0 +1,96 @@ +# FNet2D (FNet3D run Z-preserving at Z=1) fit on nucleus (Nuclei channel) — +# AICS iPSC confocal, in-focus 2D track. Mirror of the 3D +# nucleus/fnet3d_paper/ipsc_confocal fit leaf, flattened onto the offline +# 5-plane in-focus slab store cell_focus.zarr (z_window_size=1 emits one +# in-focus window per plane). +# +# The 3D ipsc leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus +# cell.zarr. The 2D track reads cell_focus.zarr instead, so the resolver is +# disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field co-declared +# with a full dataset_ref. source_channel/target_channel reproduce the +# resolver's manifest output (Phase3D / Nuclei). +# +# The fnet2d data overlay keys norm/aug/val_aug on Structure (the ER/Mito +# target), so we list-replace those three lists here to re-key to Nuclei, +# flattening the crops [32,64,64] -> [1,64,64]. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: ipsc_confocal + model_name: fnet2d + experiment_id: nucleus__ipsc_confocal__fnet2d + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered cell.zarr. dataset_ref: null makes + # the compose hook a no-op so data fields can be declared inline. + dataset_ref: null + +data: + init_args: + # iPSC in-focus slab store + channels — resolver disabled above. + source_channel: Phase3D + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Nuclei] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [1, 64, 64] + num_samples: 8 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Phase3D, Nuclei] + roi_size: [1, 64, 64] + +trainer: + logger: + init_args: + name: FNet2D_iPSC_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d/checkpoints + +launcher: + job_name: FNet2D_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D store + # (~1/4 the Z), so the 512G headroom the 3D leaf needed for cell.zarr + # mmap_preload is wasteful and delays scheduling. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..c137995a9 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,55 @@ +# FNet2D predict: nucleus (NUCL) trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis denv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=339-step=181220-loss=1.220.ckpt (loss/validate=1.220). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_denv + model_name: fnet2d + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__fnet2d__a549_mantis_h2b_denv + # Override the iPSC-side `nucleus` target with a549's gene-keyed `h2b`. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fnet2d/checkpoints/epoch=339-step=181220-loss=1.220.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__denv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_NUCL_JOINTTR_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..cc6872baf --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,55 @@ +# FNet2D predict: nucleus (NUCL) trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis mock. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=339-step=181220-loss=1.220.ckpt (loss/validate=1.220). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_mock + model_name: fnet2d + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__fnet2d__a549_mantis_h2b_mock + # Override the iPSC-side `nucleus` target with a549's gene-keyed `h2b`. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fnet2d/checkpoints/epoch=339-step=181220-loss=1.220.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__mock/prediction.zarr + +launcher: + job_name: FNet2D_PRED_NUCL_JOINTTR_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..c6ea4811e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,55 @@ +# FNet2D predict: nucleus (NUCL) trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis zikv. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=339-step=181220-loss=1.220.ckpt (loss/validate=1.220). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_zikv + model_name: fnet2d + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__fnet2d__a549_mantis_h2b_zikv + # Override the iPSC-side `nucleus` target with a549's gene-keyed `h2b`. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fnet2d/checkpoints/epoch=339-step=181220-loss=1.220.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__zikv/prediction.zarr + +launcher: + job_name: FNet2D_PRED_NUCL_JOINTTR_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..c71303452 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,52 @@ +# FNet2D predict: nucleus (NUCL) trained on joint_ipsc_confocal_a549_mantis, tested on iPSC confocal. +# In-focus 2D track (Phase F). The 2D checkpoint predicts over the FULL-Z 3D test +# store with z_window_size=1 (fnet2d_predict overlay), emitting one window per +# z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. Source normalization (Phase3D fov_statistics mean/std) reproduces the +# fnet2d fit overlay exactly; a mismatch here would silently degrade predictions. +# Best val-loss checkpoint: epoch=339-step=181220-loss=1.220.ckpt (loss/validate=1.220). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: fnet2d + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__fnet2d__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fnet2d/checkpoints/epoch=339-step=181220-loss=1.220.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/ipsc/prediction.zarr + +launcher: + job_name: FNet2D_PRED_NUCL_JOINTTR + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..535737b8e --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,126 @@ +# FNet2D (FNet3D run Z-preserving at Z=1) fit on nucleus (NUCL) — joint +# ipsc_confocal + a549_mantis pooled, in-focus 2D track. Mirror of the 3D +# nucleus/fnet3d_paper/joint_* fit leaf, flattened onto the offline 5-plane +# in-focus slab stores (z_window_size=1 emits one in-focus window per plane). +# +# BatchedConcatDataModule + two explicit HCSDataModule children; only +# model_overlays/fnet2d_fit.yml is composed (the data block is authored +# inline here, not via data_overlays). Norms + 8-crops-per-FOV diverge from +# the CellDiff/UNetViT conventions: target channel uses mean/std (not +# median/iqr) and val augmentations are CPU CenterSpatialCropd on the raw +# keys. Crops flattened [32,64,64] -> [1,64,64], z_window_size 32 -> 1. +# +# Topology: single GPU, any model, long wall — same as the 3D FNet paper +# baseline, kept so iPSC-only and joint runs are apples-to-apples. +base: + - ../../../_internal/shared/model/model_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + gene: Nuclei + target: nucleus + target_id: nucleus + train_set: joint_ipsc_confocal_a549_mantis + model_name: fnet2d + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__fnet2d + +trainer: + logger: + init_args: + name: FNet2D_JOINT_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fnet2d + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fnet2d/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Nuclei + z_window_size: 1 + # batch_size in joint mode is NOT divided by RandWeightedCropd + # num_samples (BatchedConcatDataModule.train_dataloader uses batch_size + # as-is, unlike HCSDataModule.train_dataloader which divides by + # train_patches_per_stack). To match single-set's effective on-GPU batch + # of 48 (single-set's batch_size 48 / 8), use 6 here so + # 6 indices * 8 num_samples = 48 GPU samples. + batch_size: 6 + num_workers: 8 + yx_patch_size: [64, 64] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Nuclei] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [1, 64, 64] + num_samples: 8 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandFlipd + init_args: + keys: [source, target] + spatial_axes: [1] + prob: 0.5 + - class_path: viscy_transforms.BatchedRandFlipd + init_args: + keys: [source, target] + spatial_axes: [2] + prob: 0.5 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Phase3D, Nuclei] + roi_size: [1, 64, 64] + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc in-focus slab store (Nuclei channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + # a549_mantis — pooled dual nucl+memb in-focus slab store (Nuclei channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + +launcher: + job_name: FNet2D_JOINT_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fnet2d + # 128G: the in-focus slab stores are 5-plane slices of the full-Z 3D + # stores (~1/4 the Z), so the 512G headroom the 3D joint leaf needed for + # dual mmap_preload is wasteful and delays scheduling. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..812881673 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,45 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf nucleus/fnet2d/ipsc_confocal/predict__a549_mantis_denv.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv + model_name: fnet2d_seed1 + experiment_id: nucleus__ipsc_confocal__fnet2d_seed1__a549_mantis_h2b_denv + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_seed1/ipsc/a549__denv/prediction.zarr +launcher: + job_name: FNet2D_PRED_NUCL_DENV_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_seed1/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..508d3ef4b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,45 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf nucleus/fnet2d/ipsc_confocal/predict__a549_mantis_mock.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock + model_name: fnet2d_seed1 + experiment_id: nucleus__ipsc_confocal__fnet2d_seed1__a549_mantis_h2b_mock + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_seed1/ipsc/a549__mock/prediction.zarr +launcher: + job_name: FNet2D_PRED_NUCL_MOCK_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_seed1/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..1c70e792c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,45 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf nucleus/fnet2d/ipsc_confocal/predict__a549_mantis_zikv.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv + model_name: fnet2d_seed1 + experiment_id: nucleus__ipsc_confocal__fnet2d_seed1__a549_mantis_h2b_zikv + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_seed1/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: FNet2D_PRED_NUCL_ZIKV_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_seed1/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..6af107753 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,43 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf nucleus/fnet2d/ipsc_confocal/predict__ipsc_confocal.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fnet2d_seed1 + experiment_id: nucleus__ipsc_confocal__fnet2d_seed1__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_seed1/ipsc/ipsc/prediction.zarr +launcher: + job_name: FNet2D_PRED_NUCL_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_seed1/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/train.yml new file mode 100644 index 000000000..3565dc3f9 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_seed1/ipsc_confocal/train.yml @@ -0,0 +1,86 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (fit) of the baseline leaf nucleus/fnet2d/ipsc_confocal/train.yml. +# Recipe delta vs that leaf: seed_everything: 1. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/train_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/data_overlays/fnet2d_fit.yml +- ../../../_internal/shared/model/model_overlays/fnet2d_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + train_set: ipsc_confocal + model_name: fnet2d_seed1 + experiment_id: nucleus__ipsc_confocal__fnet2d_seed1 + dataset_ref: null +data: + init_args: + source_channel: Phase3D + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Nuclei + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Nuclei + w_key: Nuclei + spatial_size: + - 1 + - 64 + - 64 + num_samples: 8 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: + - Phase3D + - Nuclei + roi_size: + - 1 + - 64 + - 64 +trainer: + logger: + init_args: + name: FNet2D_iPSC_NUCL_seed1 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d_seed1 + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: epoch={epoch}-step={step}-loss={loss/validate:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d_seed1/checkpoints +launcher: + job_name: FNet2D_NUCL_seed1 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d_seed1 + sbatch: + mem: 128G +seed_everything: 1 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..eff4db8b1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,55 @@ +# FNet2D voxel-matched predict: nucleus (NUCL) trained on ipsc_confocal, tested on A549 mantis denv. +# Voxel-matched FNet-2D ablation arm (batch 48 -> 1536 = fnet3d_paper's planes/step); +# otherwise identical to the fnet2d leaf of the same name, including the fnet2d_predict +# overlay (full-Z store, z_window_size=1) and Phase3D fov_statistics normalization. +# ckpt_path is a PROVISIONAL pin: the fit is still running and save_top_k rotates +# files out. Submit with --ckpt best (uses only the parent dir), or re-bake after the +# fit completes (tools/bake_best_ckpt.py). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv + model_name: fnet2d_voxelmatched + experiment_id: nucleus__ipsc_confocal__fnet2d_voxelmatched__a549_mantis_h2b_denv + # Override the iPSC-side `nucleus` target with a549's gene-keyed `h2b`. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d_voxelmatched/checkpoints/epoch=1114-step=11150-loss=1.274.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_voxelmatched/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: FNet2DVoxMatch_PRED_NUCL_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_voxelmatched/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..a4551b236 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,55 @@ +# FNet2D voxel-matched predict: nucleus (NUCL) trained on ipsc_confocal, tested on A549 mantis mock. +# Voxel-matched FNet-2D ablation arm (batch 48 -> 1536 = fnet3d_paper's planes/step); +# otherwise identical to the fnet2d leaf of the same name, including the fnet2d_predict +# overlay (full-Z store, z_window_size=1) and Phase3D fov_statistics normalization. +# ckpt_path is a PROVISIONAL pin: the fit is still running and save_top_k rotates +# files out. Submit with --ckpt best (uses only the parent dir), or re-bake after the +# fit completes (tools/bake_best_ckpt.py). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock + model_name: fnet2d_voxelmatched + experiment_id: nucleus__ipsc_confocal__fnet2d_voxelmatched__a549_mantis_h2b_mock + # Override the iPSC-side `nucleus` target with a549's gene-keyed `h2b`. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d_voxelmatched/checkpoints/epoch=1114-step=11150-loss=1.274.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_voxelmatched/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: FNet2DVoxMatch_PRED_NUCL_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_voxelmatched/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..2d23c5a58 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,55 @@ +# FNet2D voxel-matched predict: nucleus (NUCL) trained on ipsc_confocal, tested on A549 mantis zikv. +# Voxel-matched FNet-2D ablation arm (batch 48 -> 1536 = fnet3d_paper's planes/step); +# otherwise identical to the fnet2d leaf of the same name, including the fnet2d_predict +# overlay (full-Z store, z_window_size=1) and Phase3D fov_statistics normalization. +# ckpt_path is a PROVISIONAL pin: the fit is still running and save_top_k rotates +# files out. Submit with --ckpt best (uses only the parent dir), or re-bake after the +# fit completes (tools/bake_best_ckpt.py). +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv + model_name: fnet2d_voxelmatched + experiment_id: nucleus__ipsc_confocal__fnet2d_voxelmatched__a549_mantis_h2b_zikv + # Override the iPSC-side `nucleus` target with a549's gene-keyed `h2b`. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d_voxelmatched/checkpoints/epoch=1114-step=11150-loss=1.274.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_voxelmatched/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: FNet2DVoxMatch_PRED_NUCL_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_voxelmatched/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..50102c315 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,52 @@ +# FNet2D voxel-matched predict: nucleus (NUCL) trained on ipsc_confocal, tested on iPSC confocal. +# Voxel-matched FNet-2D ablation arm (batch 48 -> 1536 = fnet3d_paper's planes/step); +# otherwise identical to the fnet2d leaf of the same name, including the fnet2d_predict +# overlay (full-Z store, z_window_size=1) and Phase3D fov_statistics normalization. +# ckpt_path is a PROVISIONAL pin: the fit is still running and save_top_k rotates +# files out. Submit with --ckpt best (uses only the parent dir), or re-bake after the +# fit completes (tools/bake_best_ckpt.py). +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fnet2d_voxelmatched + experiment_id: nucleus__ipsc_confocal__fnet2d_voxelmatched__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d_voxelmatched/checkpoints/epoch=1114-step=11150-loss=1.274.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_voxelmatched/ipsc/ipsc/prediction.zarr + +launcher: + job_name: FNet2DVoxMatch_PRED_NUCL + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet2d_voxelmatched/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/train.yml new file mode 100644 index 000000000..5a3a21f7a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet2d_voxelmatched/ipsc_confocal/train.yml @@ -0,0 +1,97 @@ +# Voxel-matched FNet-2D ablation — nucleus (Nuclei), iPSC-trained. +# +# IDENTICAL to nucleus/fnet2d/ipsc_confocal/train.yml except batch_size +# 48 -> 1536 (and the run name/paths). fnet2d and fnet3d_paper already match on +# optimizer steps (max_steps 200000), samples/step (48), 64x64 XY patch, flip-only +# augs, lr, loss and fp32 — but fnet3d_paper's samples are 32 planes deep, so it +# supervises 48 x 32 = 1536 target planes per step against fnet2d's 48. +# 1536 = 48 x 32 closes that 32x gap. num_samples stays 8 (same crop sampler), +# so each step draws 1536 / 8 = 192 single-plane windows. +# +# Question it answers: does 3D beat 2D on the budget-matched FNet pair because of +# z-CONTEXT, or because it saw 32x more supervised voxels? If this arm closes the +# gap to fnet3d_paper, it was supervision; if it stays at fnet2d, it was context. +# Caveat: a 32x larger batch at the same constant lr also changes the optimizer's +# gradient noise, so this is a voxel-matched arm, not a pure-supervision control. +# +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet2d_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: ipsc_confocal + model_name: fnet2d_voxelmatched + experiment_id: nucleus__ipsc_confocal__fnet2d_voxelmatched + # Disable the manifest resolver: the 2D track reads the offline focus + # store, not the manifest-registered cell.zarr. dataset_ref: null makes + # the compose hook a no-op so data fields can be declared inline. + dataset_ref: null + +data: + init_args: + # 48 x 32 — voxel parity with fnet3d_paper (see header). + batch_size: 1536 + # iPSC in-focus slab store + channels — resolver disabled above. + source_channel: Phase3D + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Nuclei] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [1, 64, 64] + num_samples: 8 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Phase3D, Nuclei] + roi_size: [1, 64, 64] + +trainer: + logger: + init_args: + name: FNet2D_VoxMatch_iPSC_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d_voxelmatched + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d_voxelmatched/checkpoints + +launcher: + job_name: FNet2DVoxMatch_iPSC_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet2d_voxelmatched + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D store + # (~1/4 the Z), so the 512G headroom the 3D leaf needed for cell.zarr + # mmap_preload is wasteful and delays scheduling. + sbatch: + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/predict__a549_mantis_h2b_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/predict__a549_mantis_h2b_denv.yml new file mode 100644 index 000000000..269c656d2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/predict__a549_mantis_h2b_denv.yml @@ -0,0 +1,53 @@ +# FNet3DBigPatch predict (Phase 15): nucleus trained on iPSC, predicting against +# a549-mantis-h2b-denv test. +# Arm A of the FNet3D patch-vs-augmentation ablation: the larger 384^2 +# training patch with FNet's flip-only augmentations. +# +# Pinned to the BEST val-loss checkpoint (epoch 43, loss/validate=0.788), NOT +# `last.ckpt`: this arm's val loss rises after an early minimum, and checkpoint +# writes also stopped ~3 h before the job ended, so `last.ckpt` is neither the +# best nor the final state. +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` +# target_id from targets/nucleus.yml so the resolver finds the h2b target. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv + model_name: fnet3d_bigpatch + experiment_id: nucleus__ipsc_confocal__fnet3d_bigpatch__a549_mantis_h2b_denv + # Override the iPSC-side `nucleus` target to a549's gene-keyed `h2b`. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_bigpatch/checkpoints/epoch=43-step=114400-loss=0.788.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: FNet3DBigPatch_PRED_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/predict__a549_mantis_h2b_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/predict__a549_mantis_h2b_mock.yml new file mode 100644 index 000000000..8e97f7490 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/predict__a549_mantis_h2b_mock.yml @@ -0,0 +1,53 @@ +# FNet3DBigPatch predict (Phase 15): nucleus trained on iPSC, predicting against +# a549-mantis-h2b-mock test. +# Arm A of the FNet3D patch-vs-augmentation ablation: the larger 384^2 +# training patch with FNet's flip-only augmentations. +# +# Pinned to the BEST val-loss checkpoint (epoch 43, loss/validate=0.788), NOT +# `last.ckpt`: this arm's val loss rises after an early minimum, and checkpoint +# writes also stopped ~3 h before the job ended, so `last.ckpt` is neither the +# best nor the final state. +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` +# target_id from targets/nucleus.yml so the resolver finds the h2b target. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock + model_name: fnet3d_bigpatch + experiment_id: nucleus__ipsc_confocal__fnet3d_bigpatch__a549_mantis_h2b_mock + # Override the iPSC-side `nucleus` target to a549's gene-keyed `h2b`. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_bigpatch/checkpoints/epoch=43-step=114400-loss=0.788.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: FNet3DBigPatch_PRED_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/predict__a549_mantis_h2b_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/predict__a549_mantis_h2b_zikv.yml new file mode 100644 index 000000000..8d80c1bd1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/predict__a549_mantis_h2b_zikv.yml @@ -0,0 +1,53 @@ +# FNet3DBigPatch predict (Phase 15): nucleus trained on iPSC, predicting against +# a549-mantis-h2b-zikv test. +# Arm A of the FNet3D patch-vs-augmentation ablation: the larger 384^2 +# training patch with FNet's flip-only augmentations. +# +# Pinned to the BEST val-loss checkpoint (epoch 43, loss/validate=0.788), NOT +# `last.ckpt`: this arm's val loss rises after an early minimum, and checkpoint +# writes also stopped ~3 h before the job ended, so `last.ckpt` is neither the +# best nor the final state. +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` +# target_id from targets/nucleus.yml so the resolver finds the h2b target. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv + model_name: fnet3d_bigpatch + experiment_id: nucleus__ipsc_confocal__fnet3d_bigpatch__a549_mantis_h2b_zikv + # Override the iPSC-side `nucleus` target to a549's gene-keyed `h2b`. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_bigpatch/checkpoints/epoch=43-step=114400-loss=0.788.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: FNet3DBigPatch_PRED_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..406854e8d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,48 @@ +# FNet3DBigPatch predict (Phase 15): nucleus trained on iPSC, predicting against +# ipsc_confocal test_cropped. +# Arm A of the FNet3D patch-vs-augmentation ablation: the larger 384^2 +# training patch with FNet's flip-only augmentations. +# +# Pinned to the BEST val-loss checkpoint (epoch 43, loss/validate=0.788), NOT +# `last.ckpt`: this arm's val loss rises after an early minimum, and checkpoint +# writes also stopped ~3 h before the job ended, so `last.ckpt` is neither the +# best nor the final state. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fnet3d_bigpatch + experiment_id: nucleus__ipsc_confocal__fnet3d_bigpatch__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_bigpatch/checkpoints/epoch=43-step=114400-loss=0.788.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/ipsc/prediction.zarr + +launcher: + job_name: FNet3DBigPatch_PRED_NUCL + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/train.yml new file mode 100644 index 000000000..e1c416a9c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal/train.yml @@ -0,0 +1,83 @@ +# FNet3D "larger-patch, simple-augs" ablation (Arm A) on nucleus (Nuclei +# channel of cell.zarr) — AICS iPSC confocal. Isolates the patch-size +# effect: identical to the fnet3d_paper iPSC nucleus fit except the spatial +# patch grows 64x64 -> 384x384 (data_overlays/fnet3d_bigpatch_fit.yml) and +# precision switches to bf16-mixed. Augmentations stay FNet3D-simple (axis +# flips), so the only delta from fnet3d_vscyto3daug (Arm B) is the augs. +# The data overlay keys norm/aug/val on Structure; nucleus target_channel +# is Nuclei, so we list-replace those three lists here to re-key them. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/fnet3d_bigpatch_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: ipsc_confocal + model_name: fnet3d_bigpatch + experiment_id: nucleus__ipsc_confocal__fnet3d_bigpatch + +trainer: + # bf16-mixed halves the 384x384x32 activation footprint; MSE loss is + # immune to the bf16-SSIM cancellation issue. Must match + # fnet3d_vscyto3daug (Arm B) for a clean augmentation-only comparison. + precision: bf16-mixed + logger: + init_args: + name: FNet3D_BigPatch_iPSC_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_bigpatch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_bigpatch/checkpoints + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Nuclei] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [32, 384, 384] + num_samples: 4 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Phase3D, Nuclei] + roi_size: [32, 384, 384] + +launcher: + job_name: FNet3DBigPatch_iPSC_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_bigpatch + # 384x384x32 needs a large-memory GPU; pin H200. cell.zarr-backed preload + # pushes MaxVMSize past the shared 256G cap; mem 512G matches fnet3d iPSC. + sbatch: + constraint: h200 + mem: "512G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..743c4ffac --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml @@ -0,0 +1,66 @@ +# FNet3DBigPatchBF predict: nucleus trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_h2b_denv. +# +# Arm A of the FNet3D patch-vs-augmentation ablation: the larger 384^2 training +# patch with FNet's flip-only augmentations, now on brightfield input. +# +# Brightfield-input arm of nucleus/fnet3d_bigpatch/ipsc_confocal/predict__*.yml. Every +# field is copied from that phase baseline; the only differences are the input +# channel (dataset_ref.source_channel + the normalization key), the checkpoint, +# and the on-disk identity (train_set token `ipsc__bf`). +# +# Checkpoint is the loss/validate-monitored best, 0.6960 at epoch 59 of 0-76, +# read from the monitored ModelCheckpoint callback in last.ckpt -- that file also +# carries an unmonitored `latest-*` callback whose best_model_path is just the +# final step (epoch 76). The fit ran to `max_steps=200000` and val loss drifts up +# after the minimum, so `last.ckpt` is the wrong pin here as on the phase arm. +# Not directly comparable to the phase baseline's 0.788 (epoch 43): that +# run's checkpoint writes halted hours before it ended, so its retained best is a +# floor, not its true minimum. +# +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side +# `nucleus` target_id from targets/nucleus.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal_brightfield + predict_set: a549_mantis_h2b_denv + model_name: fnet3d_bigpatch + experiment_id: nucleus__ipsc_confocal_brightfield__fnet3d_bigpatch__a549_mantis_h2b_denv + dataset_ref: + source_channel: Brightfield + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_bigpatch/checkpoints/epoch=59-step=156000-loss=0.696.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc__bf/a549__denv/prediction.zarr + +launcher: + job_name: FNet3DBigPatchBF_PRED_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc__bf/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..7618d1f87 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml @@ -0,0 +1,66 @@ +# FNet3DBigPatchBF predict: nucleus trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_h2b_mock. +# +# Arm A of the FNet3D patch-vs-augmentation ablation: the larger 384^2 training +# patch with FNet's flip-only augmentations, now on brightfield input. +# +# Brightfield-input arm of nucleus/fnet3d_bigpatch/ipsc_confocal/predict__*.yml. Every +# field is copied from that phase baseline; the only differences are the input +# channel (dataset_ref.source_channel + the normalization key), the checkpoint, +# and the on-disk identity (train_set token `ipsc__bf`). +# +# Checkpoint is the loss/validate-monitored best, 0.6960 at epoch 59 of 0-76, +# read from the monitored ModelCheckpoint callback in last.ckpt -- that file also +# carries an unmonitored `latest-*` callback whose best_model_path is just the +# final step (epoch 76). The fit ran to `max_steps=200000` and val loss drifts up +# after the minimum, so `last.ckpt` is the wrong pin here as on the phase arm. +# Not directly comparable to the phase baseline's 0.788 (epoch 43): that +# run's checkpoint writes halted hours before it ended, so its retained best is a +# floor, not its true minimum. +# +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side +# `nucleus` target_id from targets/nucleus.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal_brightfield + predict_set: a549_mantis_h2b_mock + model_name: fnet3d_bigpatch + experiment_id: nucleus__ipsc_confocal_brightfield__fnet3d_bigpatch__a549_mantis_h2b_mock + dataset_ref: + source_channel: Brightfield + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_bigpatch/checkpoints/epoch=59-step=156000-loss=0.696.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc__bf/a549__mock/prediction.zarr + +launcher: + job_name: FNet3DBigPatchBF_PRED_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc__bf/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..b02011962 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml @@ -0,0 +1,66 @@ +# FNet3DBigPatchBF predict: nucleus trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_h2b_zikv. +# +# Arm A of the FNet3D patch-vs-augmentation ablation: the larger 384^2 training +# patch with FNet's flip-only augmentations, now on brightfield input. +# +# Brightfield-input arm of nucleus/fnet3d_bigpatch/ipsc_confocal/predict__*.yml. Every +# field is copied from that phase baseline; the only differences are the input +# channel (dataset_ref.source_channel + the normalization key), the checkpoint, +# and the on-disk identity (train_set token `ipsc__bf`). +# +# Checkpoint is the loss/validate-monitored best, 0.6960 at epoch 59 of 0-76, +# read from the monitored ModelCheckpoint callback in last.ckpt -- that file also +# carries an unmonitored `latest-*` callback whose best_model_path is just the +# final step (epoch 76). The fit ran to `max_steps=200000` and val loss drifts up +# after the minimum, so `last.ckpt` is the wrong pin here as on the phase arm. +# Not directly comparable to the phase baseline's 0.788 (epoch 43): that +# run's checkpoint writes halted hours before it ended, so its retained best is a +# floor, not its true minimum. +# +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side +# `nucleus` target_id from targets/nucleus.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal_brightfield + predict_set: a549_mantis_h2b_zikv + model_name: fnet3d_bigpatch + experiment_id: nucleus__ipsc_confocal_brightfield__fnet3d_bigpatch__a549_mantis_h2b_zikv + dataset_ref: + source_channel: Brightfield + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_bigpatch/checkpoints/epoch=59-step=156000-loss=0.696.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc__bf/a549__zikv/prediction.zarr + +launcher: + job_name: FNet3DBigPatchBF_PRED_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc__bf/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/predict__ipsc_confocal.yml new file mode 100644 index 000000000..628732b8b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/predict__ipsc_confocal.yml @@ -0,0 +1,62 @@ +# FNet3DBigPatchBF predict: nucleus trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against ipsc_confocal. +# +# Arm A of the FNet3D patch-vs-augmentation ablation: the larger 384^2 training +# patch with FNet's flip-only augmentations, now on brightfield input. +# +# Brightfield-input arm of nucleus/fnet3d_bigpatch/ipsc_confocal/predict__*.yml. Every +# field is copied from that phase baseline; the only differences are the input +# channel (dataset_ref.source_channel + the normalization key), the checkpoint, +# and the on-disk identity (train_set token `ipsc__bf`). +# +# Checkpoint is the loss/validate-monitored best, 0.6960 at epoch 59 of 0-76, +# read from the monitored ModelCheckpoint callback in last.ckpt -- that file also +# carries an unmonitored `latest-*` callback whose best_model_path is just the +# final step (epoch 76). The fit ran to `max_steps=200000` and val loss drifts up +# after the minimum, so `last.ckpt` is the wrong pin here as on the phase arm. +# Not directly comparable to the phase baseline's 0.788 (epoch 43): that +# run's checkpoint writes halted hours before it ended, so its retained best is a +# floor, not its true minimum. + +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal_brightfield + predict_set: ipsc_confocal + model_name: fnet3d_bigpatch + experiment_id: nucleus__ipsc_confocal_brightfield__fnet3d_bigpatch__ipsc_confocal + dataset_ref: + source_channel: Brightfield + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_bigpatch/checkpoints/epoch=59-step=156000-loss=0.696.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc__bf/ipsc/prediction.zarr + +launcher: + job_name: FNet3DBigPatchBF_PRED_NUCL + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_bigpatch/ipsc__bf/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/train.yml new file mode 100644 index 000000000..555ae61f5 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_bigpatch/ipsc_confocal_brightfield/train.yml @@ -0,0 +1,95 @@ +# FNet3D "larger-patch, simple-augs" ablation (Arm A) on nucleus (Nuclei +# channel of cell.zarr) — AICS iPSC confocal, BRIGHTFIELD input. +# +# The middle rung of the brightfield-vs-phase recipe ladder. Its sibling +# nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/train.yml explains why +# the ladder is needed; this leaf is what makes the answer attributable. If +# brightfield only helps once the patch grows, the useful information really +# is the defocus context that a 64x64 crop cannot see. If it only helps once +# the affine/intensity augmentations arrive, it is a regularization effect +# that has nothing to do with brightfield being the raw measurement. +# +# Geometry, batch, precision, model and optimizer are identical to the +# fnet3d_vscyto3daug brightfield arm, so those two differ ONLY in the +# gpu_augmentations stack — the same pairing the phase arms already have. +# +# The data overlay keys norm/aug/val on Phase3D + Structure; this arm's +# source is Brightfield and the nucleus target_channel is Nuclei, so all +# three lists are re-keyed here (deep_merge replaces lists wholesale). +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal_brightfield.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/fnet3d_bigpatch_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: ipsc_confocal_brightfield + model_name: fnet3d_bigpatch + experiment_id: nucleus__ipsc_confocal_brightfield__fnet3d_bigpatch + +trainer: + # bf16-mixed halves the 384x384x32 activation footprint; MSE loss is + # immune to the bf16-SSIM cancellation issue. Must match the + # fnet3d_vscyto3daug brightfield arm for a clean augmentation-only + # comparison. + precision: bf16-mixed + logger: + init_args: + name: FNet3D_BigPatch_iPSCbf_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_bigpatch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_bigpatch/checkpoints + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Nuclei] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Brightfield, Nuclei] + w_key: Nuclei + spatial_size: [32, 384, 384] + num_samples: 4 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Brightfield, Nuclei] + roi_size: [32, 384, 384] + +launcher: + job_name: FNet3DBigPatchBF_iPSC_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_bigpatch + # Same envelope as the phase sibling: 384x384x32 needs a large-memory GPU, + # pin H200. cell.zarr-backed preload pushes MaxVMSize past the shared 256G + # cap; mem 512G matches the fnet3d iPSC headroom. + sbatch: + constraint: h200 + mem: "512G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml index fce42f22a..29aa9c720 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fnet3d_paper/checkpoints/epoch=293-step=199920.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_paper/checkpoints/epoch=293-step=199920.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_a549trained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/a549__denv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_NUCL_A549TR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..78cc56958 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_denv_lite + model_name: fnet3d_paper + experiment_id: nucleus__a549_mantis__fnet3d_paper__a549_mantis_h2b_denv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_paper/checkpoints/epoch=293-step=199920.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/a549/a549__denv/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_NUCL_A549TR_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml index 7ef9a9d87..2a30d8f3d 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fnet3d_paper/checkpoints/epoch=293-step=199920.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_paper/checkpoints/epoch=293-step=199920.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_a549trained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/a549__mock/prediction.zarr launcher: job_name: FNet3DPaper_PRED_NUCL_A549TR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..9335fd974 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_mock_lite + model_name: fnet3d_paper + experiment_id: nucleus__a549_mantis__fnet3d_paper__a549_mantis_h2b_mock__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_paper/checkpoints/epoch=293-step=199920.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/a549/a549__mock/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_NUCL_A549TR_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml index 6c90d6d4c..3d582654d 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml @@ -25,7 +25,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fnet3d_paper/checkpoints/epoch=293-step=199920.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_paper/checkpoints/epoch=293-step=199920.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_a549trained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/a549__zikv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_NUCL_A549TR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..7a3226c68 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_zikv_lite + model_name: fnet3d_paper + experiment_id: nucleus__a549_mantis__fnet3d_paper__a549_mantis_h2b_zikv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_paper/checkpoints/epoch=293-step=199920.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/a549/a549__zikv/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_NUCL_A549TR_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml index 74899f44e..c484e1e84 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml @@ -19,7 +19,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fnet3d_paper/checkpoints/epoch=293-step=199920.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_paper/checkpoints/epoch=293-step=199920.ckpt data: init_args: @@ -36,8 +36,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fnet3d_paper_a549trained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/ipsc/prediction.zarr launcher: job_name: FNet3DPaper_PRED_NUCL_A549TR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..23d360259 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: ipsc_confocal_lite + model_name: fnet3d_paper + experiment_id: nucleus__a549_mantis__fnet3d_paper__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_paper/checkpoints/epoch=293-step=199920.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/a549/ipsc/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_NUCL_A549TR_IPSC_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/train.yml index 42097f045..002ecd21a 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis/train.yml @@ -53,7 +53,7 @@ trainer: logger: init_args: name: FNet3D_A549_NUCL_paper - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fnet3d_paper + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_paper callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -61,14 +61,16 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fnet3d_paper/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_paper/checkpoints launcher: job_name: FNet3DPaper_A549_NUCL - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549_mantis/nucl/fnet3d_paper + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_paper # 512G to match the shared headroom convention across the fnet3d # leaves on a549/joint workloads. mmap_preload after the BasicIndexer # fix peaks at ~75 GB for H2B_all alone (single-set) or ~185 GB for diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..728b6374c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_denv.yml @@ -0,0 +1,60 @@ +# FNet3DPaperBF predict: nucleus trained on a549_mantis_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_h2b_denv. +# +# Brightfield-input ablation arm of +# nucleus/fnet3d_paper/a549_mantis/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `a549__bf`). +# +# Checkpoint is the loss/validate-monitored best: 0.1787, better than the +# phase baseline's 0.2088 (epoch 293). Read from the monitored ModelCheckpoint +# callback in last.ckpt -- that file also carries an unmonitored `latest-*` +# callback whose best_model_path is just the final step. +# +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side +# `nucleus` target_id from targets/nucleus.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis_brightfield + predict_set: a549_mantis_h2b_denv + model_name: fnet3d_paper + experiment_id: nucleus__a549_mantis_brightfield__fnet3d_paper__a549_mantis_h2b_denv + dataset_ref: + source_channel: Brightfield + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/nucleus/fnet3d_paper/checkpoints/epoch=230-step=157080-loss=0.179.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549__bf/a549__denv/prediction.zarr + +launcher: + job_name: FNet3DPaperBF_PRED_NUCL_A549TR_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549__bf/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..97e4b3fb6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_mock.yml @@ -0,0 +1,60 @@ +# FNet3DPaperBF predict: nucleus trained on a549_mantis_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_h2b_mock. +# +# Brightfield-input ablation arm of +# nucleus/fnet3d_paper/a549_mantis/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `a549__bf`). +# +# Checkpoint is the loss/validate-monitored best: 0.1787, better than the +# phase baseline's 0.2088 (epoch 293). Read from the monitored ModelCheckpoint +# callback in last.ckpt -- that file also carries an unmonitored `latest-*` +# callback whose best_model_path is just the final step. +# +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side +# `nucleus` target_id from targets/nucleus.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis_brightfield + predict_set: a549_mantis_h2b_mock + model_name: fnet3d_paper + experiment_id: nucleus__a549_mantis_brightfield__fnet3d_paper__a549_mantis_h2b_mock + dataset_ref: + source_channel: Brightfield + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/nucleus/fnet3d_paper/checkpoints/epoch=230-step=157080-loss=0.179.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549__bf/a549__mock/prediction.zarr + +launcher: + job_name: FNet3DPaperBF_PRED_NUCL_A549TR_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549__bf/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..aa19776ac --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/predict__a549_mantis_zikv.yml @@ -0,0 +1,60 @@ +# FNet3DPaperBF predict: nucleus trained on a549_mantis_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_h2b_zikv. +# +# Brightfield-input ablation arm of +# nucleus/fnet3d_paper/a549_mantis/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `a549__bf`). +# +# Checkpoint is the loss/validate-monitored best: 0.1787, better than the +# phase baseline's 0.2088 (epoch 293). Read from the monitored ModelCheckpoint +# callback in last.ckpt -- that file also carries an unmonitored `latest-*` +# callback whose best_model_path is just the final step. +# +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side +# `nucleus` target_id from targets/nucleus.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis_brightfield + predict_set: a549_mantis_h2b_zikv + model_name: fnet3d_paper + experiment_id: nucleus__a549_mantis_brightfield__fnet3d_paper__a549_mantis_h2b_zikv + dataset_ref: + source_channel: Brightfield + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/nucleus/fnet3d_paper/checkpoints/epoch=230-step=157080-loss=0.179.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549__bf/a549__zikv/prediction.zarr + +launcher: + job_name: FNet3DPaperBF_PRED_NUCL_A549TR_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549__bf/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/predict__ipsc_confocal.yml new file mode 100644 index 000000000..184331b6d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/predict__ipsc_confocal.yml @@ -0,0 +1,56 @@ +# FNet3DPaperBF predict: nucleus trained on a549_mantis_brightfield, BRIGHTFIELD input, +# predicting against ipsc_confocal. +# +# Brightfield-input ablation arm of +# nucleus/fnet3d_paper/a549_mantis/predict__ipsc*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `a549__bf`). +# +# Checkpoint is the loss/validate-monitored best: 0.1787, better than the +# phase baseline's 0.2088 (epoch 293). Read from the monitored ModelCheckpoint +# callback in last.ckpt -- that file also carries an unmonitored `latest-*` +# callback whose best_model_path is just the final step. + +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis_brightfield + predict_set: ipsc_confocal + model_name: fnet3d_paper + experiment_id: nucleus__a549_mantis_brightfield__fnet3d_paper__ipsc_confocal + dataset_ref: + source_channel: Brightfield + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/nucleus/fnet3d_paper/checkpoints/epoch=230-step=157080-loss=0.179.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549__bf/ipsc/prediction.zarr + +launcher: + job_name: FNet3DPaperBF_PRED_NUCL_A549TR_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/a549__bf/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/train.yml new file mode 100644 index 000000000..6ccaa1f28 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/a549_mantis_brightfield/train.yml @@ -0,0 +1,85 @@ +# FNet3D paper-baseline fit on nucleus — A549 mantis-lightsheet pooled, BRIGHTFIELD input. +# +# Brightfield-input ablation arm of nucleus/fnet3d_paper/a549_mantis/train.yml. Every +# hyperparameter is identical to that baseline; the only change is the model input +# channel (Brightfield instead of the Phase3D volume reconstructed from it), which +# enters via train_sets/a549_mantis_brightfield.yml's source_channel. +# +# The three transform lists are re-authored because they name channels explicitly; +# values are copied from the COMPOSED baseline (32x64x64 crops, num_samples 8, +# Nuclei mean/std), not from the target fragment, which the fnet3d data overlay +# replaces wholesale. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis_brightfield.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: a549_mantis_brightfield + model_name: fnet3d_paper + experiment_id: nucleus__a549_mantis_brightfield__fnet3d_paper + +data: + init_args: + # A549 pooled store + target_channel — no resolver in this train_set. + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/H2B_all.zarr + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Nuclei] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Brightfield, Nuclei] + w_key: Nuclei + spatial_size: [32, 64, 64] + num_samples: 8 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Brightfield, Nuclei] + roi_size: [32, 64, 64] + +trainer: + logger: + init_args: + name: FNet3D_A549bf_NUCL_paper + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/nucleus/fnet3d_paper + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/nucleus/fnet3d_paper/checkpoints + +launcher: + job_name: FNet3DPaperBF_A549_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549__bf/nucleus/fnet3d_paper + # 512G to match the shared headroom convention across the fnet3d + # leaves on a549/joint workloads (mmap_preload peaks at ~75 GB for + # H2B_all alone); carried over from the phase baseline unchanged. + sbatch: + mem: "512G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index aac52b2f2..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Nucleus (H2B) predicted by FNet3DPaper on a549-mantis-h2b-denv. -# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` -# target_id from the target group so the resolver finds h2b on a549-mantis-h2b-denv. -defaults: - - override /target: nucleus - - override /predict_set: a549_mantis_h2b_denv - -benchmark: - dataset_ref: - target: h2b - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_nucl_fnet3d_paper_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index a989ac16e..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Nucleus (H2B) predicted by FNet3DPaper on a549-mantis-h2b-mock. -# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` -# target_id from the target group so the resolver finds h2b on a549-mantis-h2b-mock. -defaults: - - override /target: nucleus - - override /predict_set: a549_mantis_h2b_mock - -benchmark: - dataset_ref: - target: h2b - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_nucl_fnet3d_paper_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index 050db00da..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Nucleus (H2B) predicted by FNet3DPaper on a549-mantis-h2b-zikv. -# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` -# target_id from the target group so the resolver finds h2b on a549-mantis-h2b-zikv. -defaults: - - override /target: nucleus - - override /predict_set: a549_mantis_h2b_zikv - -benchmark: - dataset_ref: - target: h2b - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_nucl_fnet3d_paper_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml index d8bb88fa2..8c3dbe43e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml @@ -24,7 +24,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fnet3d_paper/checkpoints/epoch=226-step=196582.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_paper/checkpoints/epoch=226-step=196582.ckpt data: init_args: @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/a549__denv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_NUCL_ON_A549_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..4287775f7 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv_lite + model_name: fnet3d_paper + experiment_id: nucleus__ipsc_confocal__fnet3d_paper__a549_mantis_h2b_denv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_paper/checkpoints/epoch=226-step=196582.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/ipsc/a549__denv/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_NUCL_ON_A549_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml index f8f61d38c..e9a7ee67b 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml @@ -24,7 +24,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fnet3d_paper/checkpoints/epoch=226-step=196582.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_paper/checkpoints/epoch=226-step=196582.ckpt data: init_args: @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/a549__mock/prediction.zarr launcher: job_name: FNet3DPaper_PRED_NUCL_ON_A549_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..f04fa9aa7 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock_lite + model_name: fnet3d_paper + experiment_id: nucleus__ipsc_confocal__fnet3d_paper__a549_mantis_h2b_mock__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_paper/checkpoints/epoch=226-step=196582.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/ipsc/a549__mock/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_NUCL_ON_A549_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml index 56b773fae..4ac6a0de3 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -24,7 +24,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fnet3d_paper/checkpoints/epoch=226-step=196582.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_paper/checkpoints/epoch=226-step=196582.ckpt data: init_args: @@ -41,8 +41,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/a549__zikv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_NUCL_ON_A549_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..06d0255b5 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv_lite + model_name: fnet3d_paper + experiment_id: nucleus__ipsc_confocal__fnet3d_paper__a549_mantis_h2b_zikv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_paper/checkpoints/epoch=226-step=196582.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_NUCL_ON_A549_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml index cc5a3b93b..de3ef326f 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml @@ -18,7 +18,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fnet3d_paper/checkpoints/epoch=226-step=196582.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_paper/checkpoints/epoch=226-step=196582.ckpt data: init_args: @@ -35,8 +35,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fnet3d_paper.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/ipsc/prediction.zarr launcher: job_name: FNet3DPaper_PRED_NUCL - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..5c34a7588 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: fnet3d_paper + experiment_id: nucleus__ipsc_confocal__fnet3d_paper__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_paper/checkpoints/epoch=226-step=196582.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/ipsc/ipsc/prediction.zarr +launcher: + job_name: FNet3DPaper_PRED_NUCL_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/fnet3d_paper/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/train.yml index 6978bc815..e2804de9c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal/train.yml @@ -50,7 +50,7 @@ trainer: logger: init_args: name: FNet3D_iPSC_NUCL_paper - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fnet3d_paper + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_paper callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -58,14 +58,16 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fnet3d_paper/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_paper/checkpoints launcher: job_name: FNet3DPaper_NUCL - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucl/fnet3d_paper + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_paper # cell.zarr-backed preload pushes MaxVMSize past the shared 256G cap # (observed 264G on the first launch; worker OOM-killed in validation). sbatch: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..b7fdf7055 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml @@ -0,0 +1,60 @@ +# FNet3DPaperBF predict: nucleus trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_h2b_denv. +# +# Brightfield-input ablation arm of +# nucleus/fnet3d_paper/ipsc_confocal/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `ipsc__bf`). +# +# Checkpoint is the loss/validate-monitored best: 0.7935, at parity with the +# phase baseline's 0.7932 (epoch 226). Read from the monitored ModelCheckpoint +# callback in last.ckpt -- that file also carries an unmonitored `latest-*` +# callback whose best_model_path is just the final step. +# +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side +# `nucleus` target_id from targets/nucleus.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal_brightfield + predict_set: a549_mantis_h2b_denv + model_name: fnet3d_paper + experiment_id: nucleus__ipsc_confocal_brightfield__fnet3d_paper__a549_mantis_h2b_denv + dataset_ref: + source_channel: Brightfield + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_paper/checkpoints/epoch=208-step=180994-loss=0.794.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc__bf/a549__denv/prediction.zarr + +launcher: + job_name: FNet3DPaperBF_PRED_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc__bf/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..e5670cc4c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml @@ -0,0 +1,60 @@ +# FNet3DPaperBF predict: nucleus trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_h2b_mock. +# +# Brightfield-input ablation arm of +# nucleus/fnet3d_paper/ipsc_confocal/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `ipsc__bf`). +# +# Checkpoint is the loss/validate-monitored best: 0.7935, at parity with the +# phase baseline's 0.7932 (epoch 226). Read from the monitored ModelCheckpoint +# callback in last.ckpt -- that file also carries an unmonitored `latest-*` +# callback whose best_model_path is just the final step. +# +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side +# `nucleus` target_id from targets/nucleus.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal_brightfield + predict_set: a549_mantis_h2b_mock + model_name: fnet3d_paper + experiment_id: nucleus__ipsc_confocal_brightfield__fnet3d_paper__a549_mantis_h2b_mock + dataset_ref: + source_channel: Brightfield + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_paper/checkpoints/epoch=208-step=180994-loss=0.794.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc__bf/a549__mock/prediction.zarr + +launcher: + job_name: FNet3DPaperBF_PRED_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc__bf/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..5e893d1e2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml @@ -0,0 +1,60 @@ +# FNet3DPaperBF predict: nucleus trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_h2b_zikv. +# +# Brightfield-input ablation arm of +# nucleus/fnet3d_paper/ipsc_confocal/predict__a549*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `ipsc__bf`). +# +# Checkpoint is the loss/validate-monitored best: 0.7935, at parity with the +# phase baseline's 0.7932 (epoch 226). Read from the monitored ModelCheckpoint +# callback in last.ckpt -- that file also carries an unmonitored `latest-*` +# callback whose best_model_path is just the final step. +# +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side +# `nucleus` target_id from targets/nucleus.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal_brightfield + predict_set: a549_mantis_h2b_zikv + model_name: fnet3d_paper + experiment_id: nucleus__ipsc_confocal_brightfield__fnet3d_paper__a549_mantis_h2b_zikv + dataset_ref: + source_channel: Brightfield + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_paper/checkpoints/epoch=208-step=180994-loss=0.794.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc__bf/a549__zikv/prediction.zarr + +launcher: + job_name: FNet3DPaperBF_PRED_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc__bf/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/predict__ipsc_confocal.yml new file mode 100644 index 000000000..567de0a0f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/predict__ipsc_confocal.yml @@ -0,0 +1,56 @@ +# FNet3DPaperBF predict: nucleus trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against ipsc_confocal. +# +# Brightfield-input ablation arm of +# nucleus/fnet3d_paper/ipsc_confocal/predict__ipsc*.yml. Every field is copied +# from that phase baseline; the only differences are the input channel +# (dataset_ref.source_channel + the normalization key), the checkpoint, and the +# on-disk identity (train_set token `ipsc__bf`). +# +# Checkpoint is the loss/validate-monitored best: 0.7935, at parity with the +# phase baseline's 0.7932 (epoch 226). Read from the monitored ModelCheckpoint +# callback in last.ckpt -- that file also carries an unmonitored `latest-*` +# callback whose best_model_path is just the final step. + +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal_brightfield + predict_set: ipsc_confocal + model_name: fnet3d_paper + experiment_id: nucleus__ipsc_confocal_brightfield__fnet3d_paper__ipsc_confocal + dataset_ref: + source_channel: Brightfield + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_paper/checkpoints/epoch=208-step=180994-loss=0.794.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc__bf/ipsc/prediction.zarr + +launcher: + job_name: FNet3DPaperBF_PRED_NUCL + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/ipsc__bf/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/train.yml new file mode 100644 index 000000000..8019f18b5 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/ipsc_confocal_brightfield/train.yml @@ -0,0 +1,83 @@ +# FNet3D paper-baseline fit on nucleus — AICS iPSC confocal, BRIGHTFIELD input. +# +# Brightfield-input ablation arm of nucleus/fnet3d_paper/ipsc_confocal/train.yml. +# Every hyperparameter is identical to that baseline; the only change is the model +# input channel (Brightfield instead of the Phase3D volume reconstructed from it), +# which enters via train_sets/ipsc_confocal_brightfield.yml's +# dataset_ref.source_channel. +# +# The three transform lists are re-authored here because they name channels +# explicitly. Values are copied from the composed baseline, NOT from the target +# fragment: data_overlays/fnet3d_paper_fit.yml composes after targets/nucleus.yml +# and replaces all three lists (deep_merge replaces lists wholesale), so the live +# values are 32x64x64 crops with num_samples 8, not the target's 13x624x624 / 2. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal_brightfield.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: ipsc_confocal_brightfield + model_name: fnet3d_paper + experiment_id: nucleus__ipsc_confocal_brightfield__fnet3d_paper + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Nuclei] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Brightfield, Nuclei] + w_key: Nuclei + spatial_size: [32, 64, 64] + num_samples: 8 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Brightfield, Nuclei] + roi_size: [32, 64, 64] + +trainer: + logger: + init_args: + name: FNet3D_iPSCbf_NUCL_paper + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_paper + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_paper/checkpoints + +launcher: + job_name: FNet3DPaperBF_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_paper + # cell.zarr-backed preload pushes MaxVMSize past the shared 256G cap + # (observed 264G on the first launch; worker OOM-killed in validation). + sbatch: + mem: "512G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index 0868b75ee..fc605997c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -26,7 +26,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fnet3d_paper/checkpoints/epoch=126-step=196342.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fnet3d_paper/checkpoints/epoch=126-step=196342.ckpt data: init_args: @@ -43,8 +43,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_jointtrained_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/a549__denv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_NUCL_JOINTTR_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index a6eda96b6..d7788d031 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -26,7 +26,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fnet3d_paper/checkpoints/epoch=126-step=196342.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fnet3d_paper/checkpoints/epoch=126-step=196342.ckpt data: init_args: @@ -43,8 +43,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_jointtrained_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/a549__mock/prediction.zarr launcher: job_name: FNet3DPaper_PRED_NUCL_JOINTTR_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index f7d4c170f..f43178dd9 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -26,7 +26,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fnet3d_paper/checkpoints/epoch=126-step=196342.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fnet3d_paper/checkpoints/epoch=126-step=196342.ckpt data: init_args: @@ -43,8 +43,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_fnet3d_paper_jointtrained_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/a549__zikv/prediction.zarr launcher: job_name: FNet3DPaper_PRED_NUCL_JOINTTR_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index 79361b568..5f638e3fd 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -20,7 +20,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fnet3d_paper/checkpoints/epoch=126-step=196342.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fnet3d_paper/checkpoints/epoch=126-step=196342.ckpt data: init_args: @@ -37,8 +37,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_fnet3d_paper_jointtrained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/ipsc/prediction.zarr launcher: job_name: FNet3DPaper_PRED_NUCL_JOINTTR_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_paper/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/train.yml index 2ba6acbec..8c102e173 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_paper/joint_ipsc_confocal_a549_mantis/train.yml @@ -34,7 +34,7 @@ trainer: logger: init_args: name: FNet3D_JOINT_NUCL_paper - save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fnet3d_paper + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fnet3d_paper callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -42,10 +42,12 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fnet3d_paper/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fnet3d_paper/checkpoints _hcs_init_args: &hcs_init_args source_channel: Phase3D @@ -118,7 +120,7 @@ data: launcher: job_name: FNet3DPaper_JOINT_NUCL - run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint_ipsc_confocal_a549_mantis/nucl/fnet3d_paper + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/fnet3d_paper # 512G to match the shared headroom convention across the fnet3d # leaves on a549/joint workloads. mmap_preload after the BasicIndexer # fix peaks at ~185 GB for joint cell.zarr + H2B_all; 512G gives diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/predict__a549_mantis_h2b_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/predict__a549_mantis_h2b_denv.yml new file mode 100644 index 000000000..66618596a --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/predict__a549_mantis_h2b_denv.yml @@ -0,0 +1,60 @@ +# FNet3D temporal-sampling ablation (Phase 17) predict: nucleus arm `fnet3d_t01` +# trained on a549_mantis, predicting a549-mantis-h2b-denv. +# +# This arm trained on timepoints {0,1} only (hpi 5 and 7), at the +# same frame budget as its partner. The A549 test set spans hpi 5->23, so it is the +# shared yardstick: the two arms validate on DIFFERENT frames (each on its own subset +# store), which makes `loss/validate` incomparable across arms. These predicts are the +# only valid cross-arm comparison. +# +# The pinned `ckpt_path` below is PROVISIONAL -- the best-by-monitor checkpoint as of +# 2026-07-30 11:00, while the fit is still running. Submit with `--ckpt best`, which +# takes only the parent directory from this path and re-resolves `best_model_path` +# from the newest `last*.ckpt` at submit time. `save_top_k: 4` may well have rotated +# this exact file away by then; that is expected and harmless. +# NEVER pin `last.ckpt`: these arms' val curves are noisy (epoch IQR 0.066-0.237, +# larger than the whole second-half trend), so `last` lands at an arbitrary point in +# the jitter -- nucleus/fnet3d_t01's `last` was val 0.166 against a best of 0.078. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_denv + model_name: fnet3d_t01 + experiment_id: nucleus__a549_mantis__fnet3d_t01__a549_mantis_h2b_denv + # A549 keys nucleus by gene; override the iPSC-side `nucleus` target_id. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_t01/checkpoints/epoch=1359-step=184960-loss=0.027.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_t01/a549/a549__denv/prediction.zarr + +launcher: + job_name: FNet3DT01_PRED_NUCL_A549TR_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_t01/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/predict__a549_mantis_h2b_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/predict__a549_mantis_h2b_mock.yml new file mode 100644 index 000000000..3f04573fa --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/predict__a549_mantis_h2b_mock.yml @@ -0,0 +1,60 @@ +# FNet3D temporal-sampling ablation (Phase 17) predict: nucleus arm `fnet3d_t01` +# trained on a549_mantis, predicting a549-mantis-h2b-mock. +# +# This arm trained on timepoints {0,1} only (hpi 5 and 7), at the +# same frame budget as its partner. The A549 test set spans hpi 5->23, so it is the +# shared yardstick: the two arms validate on DIFFERENT frames (each on its own subset +# store), which makes `loss/validate` incomparable across arms. These predicts are the +# only valid cross-arm comparison. +# +# The pinned `ckpt_path` below is PROVISIONAL -- the best-by-monitor checkpoint as of +# 2026-07-30 11:00, while the fit is still running. Submit with `--ckpt best`, which +# takes only the parent directory from this path and re-resolves `best_model_path` +# from the newest `last*.ckpt` at submit time. `save_top_k: 4` may well have rotated +# this exact file away by then; that is expected and harmless. +# NEVER pin `last.ckpt`: these arms' val curves are noisy (epoch IQR 0.066-0.237, +# larger than the whole second-half trend), so `last` lands at an arbitrary point in +# the jitter -- nucleus/fnet3d_t01's `last` was val 0.166 against a best of 0.078. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_mock + model_name: fnet3d_t01 + experiment_id: nucleus__a549_mantis__fnet3d_t01__a549_mantis_h2b_mock + # A549 keys nucleus by gene; override the iPSC-side `nucleus` target_id. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_t01/checkpoints/epoch=1359-step=184960-loss=0.027.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_t01/a549/a549__mock/prediction.zarr + +launcher: + job_name: FNet3DT01_PRED_NUCL_A549TR_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_t01/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/predict__a549_mantis_h2b_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/predict__a549_mantis_h2b_zikv.yml new file mode 100644 index 000000000..1acdaa0c9 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/predict__a549_mantis_h2b_zikv.yml @@ -0,0 +1,60 @@ +# FNet3D temporal-sampling ablation (Phase 17) predict: nucleus arm `fnet3d_t01` +# trained on a549_mantis, predicting a549-mantis-h2b-zikv. +# +# This arm trained on timepoints {0,1} only (hpi 5 and 7), at the +# same frame budget as its partner. The A549 test set spans hpi 5->23, so it is the +# shared yardstick: the two arms validate on DIFFERENT frames (each on its own subset +# store), which makes `loss/validate` incomparable across arms. These predicts are the +# only valid cross-arm comparison. +# +# The pinned `ckpt_path` below is PROVISIONAL -- the best-by-monitor checkpoint as of +# 2026-07-30 11:00, while the fit is still running. Submit with `--ckpt best`, which +# takes only the parent directory from this path and re-resolves `best_model_path` +# from the newest `last*.ckpt` at submit time. `save_top_k: 4` may well have rotated +# this exact file away by then; that is expected and harmless. +# NEVER pin `last.ckpt`: these arms' val curves are noisy (epoch IQR 0.066-0.237, +# larger than the whole second-half trend), so `last` lands at an arbitrary point in +# the jitter -- nucleus/fnet3d_t01's `last` was val 0.166 against a best of 0.078. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_zikv + model_name: fnet3d_t01 + experiment_id: nucleus__a549_mantis__fnet3d_t01__a549_mantis_h2b_zikv + # A549 keys nucleus by gene; override the iPSC-side `nucleus` target_id. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_t01/checkpoints/epoch=1359-step=184960-loss=0.027.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_t01/a549/a549__zikv/prediction.zarr + +launcher: + job_name: FNet3DT01_PRED_NUCL_A549TR_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_t01/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/train.yml new file mode 100644 index 000000000..a4c5aae44 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/train.yml @@ -0,0 +1,106 @@ +# FNet3D temporal-sampling ablation, Arm A "early window" (Phase 17). +# +# Identical to nucleus/fnet3d_paper/a549_mantis/train.yml except `data_path`: this +# arm reads H2B_t01.zarr, the timepoint-subset store holding timepoints {0, 1} of +# every position — hpi 5 and 7, a two-hour window at the start of infection. Its +# partner `fnet3d_tspread` reads the same number of frames spread over the whole +# 5->23 hpi course, so the pair isolates temporal diversity at a fixed frame budget. +# The full-time-course fnet3d_paper fit is the third rung (the ceiling). +# +# Built by tools/build_temporal_subset_zarr.py --mode early --n-timepoints 2. +# 30 positions x 2 frames -> 24 train / 6 val positions (split_ratio 0.8), 48 train +# and 12 val (position, timepoint) pairs. Because HCSDataModule splits by POSITION +# under seed_everything: 0, both arms draw the identical permutation and therefore +# the identical train/val positions. +# +# The overlay's norm/aug/val_aug are keyed on Structure (the SEC61B/TOMM20 target +# channel). Nucleus target_channel is Nuclei, so we list-replace those three lists +# here to re-key them. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: a549_mantis + model_name: fnet3d_t01 + experiment_id: nucleus__a549_mantis__fnet3d_t01 + +data: + init_args: + # A549 pooled store + target_channel — no resolver in this train_set. + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/H2B_t01.zarr + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Nuclei] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [32, 64, 64] + num_samples: 8 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Phase3D, Nuclei] + roi_size: [32, 64, 64] + +trainer: + logger: + init_args: + name: FNet3D_A549_NUCL_t01 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_t01 + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + # 1/5 the frames means 1/5 the steps per epoch: 816 windows / 6 windows + # per step = 136 steps/epoch, so max_steps 200000 is ~1470 epochs. At + # every_n_epochs 1 that is ~1470 write-then-delete cycles of a 424 MB + # checkpoint, and long fnet/fcmae runs have silently stopped writing + # checkpoints three times now. 147 monitor events is ample selection + # granularity; validation still runs every epoch. + every_n_epochs: 10 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_t01/checkpoints + +launcher: + job_name: FNet3DT01_A549_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_t01 + sbatch: + # The fnet3d_paper a549 leaf asks for 512G because staging the FULL pooled + # store peaks ~75 GB; this arm stages 60 frames x 2 channels (~14 GB), so 96G + # is generous. 16 CPUs likewise covers num_workers 8 with persistent workers. + # Both cuts matter for scheduling, not for results. + # + # Constrained OFF the >=80 GB pool (a100_80/h100_80/h200) on purpose: the + # concurrent re-eval campaign needs those cards for cold deep-feature + # extraction, and this fit does not — the paper baseline trained the same + # patch/batch/precision on an A6000. + constraint: "a6000|a40|l40s" + cpus_per_task: 16 + mem: "96G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/train_smoke.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/train_smoke.yml new file mode 100644 index 000000000..419e4753c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_t01/a549_mantis/train_smoke.yml @@ -0,0 +1,70 @@ +# Smoke sibling of nucleus/fnet3d_t01/a549_mantis/train.yml. +# Proves the derived timepoint-subset store is trainable before four 1.6-day fits +# launch on it: that H2B_t01.zarr's `fov_statistics` normalization metadata survived +# the subset copy, that mmap_preload stages a 2-frame-per-position store (the arm's +# whole point, and the code path the real fit uses), that RandWeightedCropd finds +# foreground in only 2 frames per FOV, and that train + val forward/backward give +# finite MSE. Deliberately keeps mmap_preload ON — a lazy-read smoke would skip the +# one staging path this store has never exercised. +# Scratch run_root, no logger, no checkpoints (so no junk last.ckpt can shadow the +# real run), 30 steps, bounded 40-min wall. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: a549_mantis + model_name: fnet3d_t01 + experiment_id: nucleus__a549_mantis__fnet3d_t01__smoke + +trainer: + max_steps: 30 + limit_val_batches: 2 + logger: false + callbacks: [] + +data: + init_args: + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/H2B_t01.zarr + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Nuclei] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [32, 64, 64] + num_samples: 8 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Phase3D, Nuclei] + roi_size: [32, 64, 64] + +launcher: + job_name: FNet3DT01_NUCL_SMOKE + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/_smoke/fnet3d_t01_a549_nucleus + sbatch: + constraint: "a6000|a40|l40s" + cpus_per_task: 16 + mem: "96G" + time: "00:40:00" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_tspread/a549_mantis/predict__a549_mantis_h2b_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_tspread/a549_mantis/predict__a549_mantis_h2b_denv.yml new file mode 100644 index 000000000..fa3054cbe --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_tspread/a549_mantis/predict__a549_mantis_h2b_denv.yml @@ -0,0 +1,60 @@ +# FNet3D temporal-sampling ablation (Phase 17) predict: nucleus arm `fnet3d_tspread` +# trained on a549_mantis, predicting a549-mantis-h2b-denv. +# +# This arm trained on 2 timepoints spread across each position's full 5->23 hpi range, at the +# same frame budget as its partner. The A549 test set spans hpi 5->23, so it is the +# shared yardstick: the two arms validate on DIFFERENT frames (each on its own subset +# store), which makes `loss/validate` incomparable across arms. These predicts are the +# only valid cross-arm comparison. +# +# The pinned `ckpt_path` below is PROVISIONAL -- the best-by-monitor checkpoint as of +# 2026-07-30 11:00, while the fit is still running. Submit with `--ckpt best`, which +# takes only the parent directory from this path and re-resolves `best_model_path` +# from the newest `last*.ckpt` at submit time. `save_top_k: 4` may well have rotated +# this exact file away by then; that is expected and harmless. +# NEVER pin `last.ckpt`: these arms' val curves are noisy (epoch IQR 0.066-0.237, +# larger than the whole second-half trend), so `last` lands at an arbitrary point in +# the jitter -- nucleus/fnet3d_t01's `last` was val 0.166 against a best of 0.078. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_denv + model_name: fnet3d_tspread + experiment_id: nucleus__a549_mantis__fnet3d_tspread__a549_mantis_h2b_denv + # A549 keys nucleus by gene; override the iPSC-side `nucleus` target_id. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_tspread/checkpoints/epoch=479-step=65280-loss=0.109.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_tspread/a549/a549__denv/prediction.zarr + +launcher: + job_name: FNet3DTSpread_PRED_NUCL_A549TR_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_tspread/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_tspread/a549_mantis/predict__a549_mantis_h2b_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_tspread/a549_mantis/predict__a549_mantis_h2b_mock.yml new file mode 100644 index 000000000..aa7079ce6 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_tspread/a549_mantis/predict__a549_mantis_h2b_mock.yml @@ -0,0 +1,60 @@ +# FNet3D temporal-sampling ablation (Phase 17) predict: nucleus arm `fnet3d_tspread` +# trained on a549_mantis, predicting a549-mantis-h2b-mock. +# +# This arm trained on 2 timepoints spread across each position's full 5->23 hpi range, at the +# same frame budget as its partner. The A549 test set spans hpi 5->23, so it is the +# shared yardstick: the two arms validate on DIFFERENT frames (each on its own subset +# store), which makes `loss/validate` incomparable across arms. These predicts are the +# only valid cross-arm comparison. +# +# The pinned `ckpt_path` below is PROVISIONAL -- the best-by-monitor checkpoint as of +# 2026-07-30 11:00, while the fit is still running. Submit with `--ckpt best`, which +# takes only the parent directory from this path and re-resolves `best_model_path` +# from the newest `last*.ckpt` at submit time. `save_top_k: 4` may well have rotated +# this exact file away by then; that is expected and harmless. +# NEVER pin `last.ckpt`: these arms' val curves are noisy (epoch IQR 0.066-0.237, +# larger than the whole second-half trend), so `last` lands at an arbitrary point in +# the jitter -- nucleus/fnet3d_t01's `last` was val 0.166 against a best of 0.078. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_mock + model_name: fnet3d_tspread + experiment_id: nucleus__a549_mantis__fnet3d_tspread__a549_mantis_h2b_mock + # A549 keys nucleus by gene; override the iPSC-side `nucleus` target_id. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_tspread/checkpoints/epoch=479-step=65280-loss=0.109.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_tspread/a549/a549__mock/prediction.zarr + +launcher: + job_name: FNet3DTSpread_PRED_NUCL_A549TR_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_tspread/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_tspread/a549_mantis/predict__a549_mantis_h2b_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_tspread/a549_mantis/predict__a549_mantis_h2b_zikv.yml new file mode 100644 index 000000000..f838ec194 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_tspread/a549_mantis/predict__a549_mantis_h2b_zikv.yml @@ -0,0 +1,60 @@ +# FNet3D temporal-sampling ablation (Phase 17) predict: nucleus arm `fnet3d_tspread` +# trained on a549_mantis, predicting a549-mantis-h2b-zikv. +# +# This arm trained on 2 timepoints spread across each position's full 5->23 hpi range, at the +# same frame budget as its partner. The A549 test set spans hpi 5->23, so it is the +# shared yardstick: the two arms validate on DIFFERENT frames (each on its own subset +# store), which makes `loss/validate` incomparable across arms. These predicts are the +# only valid cross-arm comparison. +# +# The pinned `ckpt_path` below is PROVISIONAL -- the best-by-monitor checkpoint as of +# 2026-07-30 11:00, while the fit is still running. Submit with `--ckpt best`, which +# takes only the parent directory from this path and re-resolves `best_model_path` +# from the newest `last*.ckpt` at submit time. `save_top_k: 4` may well have rotated +# this exact file away by then; that is expected and harmless. +# NEVER pin `last.ckpt`: these arms' val curves are noisy (epoch IQR 0.066-0.237, +# larger than the whole second-half trend), so `last` lands at an arbitrary point in +# the jitter -- nucleus/fnet3d_t01's `last` was val 0.166 against a best of 0.078. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_zikv + model_name: fnet3d_tspread + experiment_id: nucleus__a549_mantis__fnet3d_tspread__a549_mantis_h2b_zikv + # A549 keys nucleus by gene; override the iPSC-side `nucleus` target_id. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_tspread/checkpoints/epoch=479-step=65280-loss=0.109.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_tspread/a549/a549__zikv/prediction.zarr + +launcher: + job_name: FNet3DTSpread_PRED_NUCL_A549TR_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_tspread/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_tspread/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_tspread/a549_mantis/train.yml new file mode 100644 index 000000000..288cd7cbe --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_tspread/a549_mantis/train.yml @@ -0,0 +1,107 @@ +# FNet3D temporal-sampling ablation, Arm B "spread" (Phase 17). +# +# Identical to nucleus/fnet3d_paper/a549_mantis/train.yml except `data_path`: this +# arm reads H2B_tspread.zarr, which holds 2 timepoints per position spread over that +# position's own range (plate ordinal i takes t = i % 10 and (i % 10 + 5) % 10 — a +# 10-hour separation on the store's 2 h grid, with every hpi used by exactly 6 of +# the 60 frames). Its partner `fnet3d_t01` reads the SAME number of frames from a +# two-hour early window (hpi 5 and 7), so the pair isolates temporal diversity at a +# fixed frame budget. The full-time-course fnet3d_paper fit is the third rung. +# +# Built by tools/build_temporal_subset_zarr.py --mode spread --n-timepoints 2. +# 30 positions x 2 frames -> 24 train / 6 val positions (split_ratio 0.8), 48 train +# and 12 val (position, timepoint) pairs. Because HCSDataModule splits by POSITION +# under seed_everything: 0, both arms draw the identical permutation and therefore +# the identical train/val positions. +# +# The overlay's norm/aug/val_aug are keyed on Structure (the SEC61B/TOMM20 target +# channel). Nucleus target_channel is Nuclei, so we list-replace those three lists +# here to re-key them. +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: a549_mantis + model_name: fnet3d_tspread + experiment_id: nucleus__a549_mantis__fnet3d_tspread + +data: + init_args: + # A549 pooled store + target_channel — no resolver in this train_set. + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/H2B_tspread.zarr + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Nuclei] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [32, 64, 64] + num_samples: 8 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Phase3D, Nuclei] + roi_size: [32, 64, 64] + +trainer: + logger: + init_args: + name: FNet3D_A549_NUCL_tspread + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_tspread + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + # 1/5 the frames means 1/5 the steps per epoch: 816 windows / 6 windows + # per step = 136 steps/epoch, so max_steps 200000 is ~1470 epochs. At + # every_n_epochs 1 that is ~1470 write-then-delete cycles of a 424 MB + # checkpoint, and long fnet/fcmae runs have silently stopped writing + # checkpoints three times now. 147 monitor events is ample selection + # granularity; validation still runs every epoch. + every_n_epochs: 10 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_tspread/checkpoints + +launcher: + job_name: FNet3DTSpread_A549_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/fnet3d_tspread + sbatch: + # The fnet3d_paper a549 leaf asks for 512G because staging the FULL pooled + # store peaks ~75 GB; this arm stages 60 frames x 2 channels (~14 GB), so 96G + # is generous. 16 CPUs likewise covers num_workers 8 with persistent workers. + # Both cuts matter for scheduling, not for results. + # + # Constrained OFF the >=80 GB pool (a100_80/h100_80/h200) on purpose: the + # concurrent re-eval campaign needs those cards for cold deep-feature + # extraction, and this fit does not — the paper baseline trained the same + # patch/batch/precision on an A6000. + constraint: "a6000|a40|l40s" + cpus_per_task: 16 + mem: "96G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__a549_mantis_h2b_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__a549_mantis_h2b_denv.yml new file mode 100644 index 000000000..15954f8db --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__a549_mantis_h2b_denv.yml @@ -0,0 +1,54 @@ +# FNet3DVSAug predict (Phase 15): nucleus trained on iPSC, predicting against +# a549-mantis-h2b-denv test. +# Arm B of the FNet3D patch-vs-augmentation ablation: the same larger +# 384^2 patch plus the full VSCyto3D augmentation stack. Arm A vs Arm B is the +# clean augmentation comparison (identical geometry, batch and precision). +# +# Pinned to the BEST val-loss checkpoint (epoch 28, loss/validate=0.776), NOT +# `last.ckpt`: this arm's val loss rises after an early minimum, and checkpoint +# writes also stopped ~3 h before the job ended, so `last.ckpt` is neither the +# best nor the final state. +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` +# target_id from targets/nucleus.yml so the resolver finds the h2b target. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv + model_name: fnet3d_vscyto3daug + experiment_id: nucleus__ipsc_confocal__fnet3d_vscyto3daug__a549_mantis_h2b_denv + # Override the iPSC-side `nucleus` target to a549's gene-keyed `h2b`. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_vscyto3daug/checkpoints/epoch=28-step=75400-loss=0.776.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: FNet3DVSAug_PRED_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__a549_mantis_h2b_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__a549_mantis_h2b_mock.yml new file mode 100644 index 000000000..367e54ed0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__a549_mantis_h2b_mock.yml @@ -0,0 +1,54 @@ +# FNet3DVSAug predict (Phase 15): nucleus trained on iPSC, predicting against +# a549-mantis-h2b-mock test. +# Arm B of the FNet3D patch-vs-augmentation ablation: the same larger +# 384^2 patch plus the full VSCyto3D augmentation stack. Arm A vs Arm B is the +# clean augmentation comparison (identical geometry, batch and precision). +# +# Pinned to the BEST val-loss checkpoint (epoch 28, loss/validate=0.776), NOT +# `last.ckpt`: this arm's val loss rises after an early minimum, and checkpoint +# writes also stopped ~3 h before the job ended, so `last.ckpt` is neither the +# best nor the final state. +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` +# target_id from targets/nucleus.yml so the resolver finds the h2b target. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock + model_name: fnet3d_vscyto3daug + experiment_id: nucleus__ipsc_confocal__fnet3d_vscyto3daug__a549_mantis_h2b_mock + # Override the iPSC-side `nucleus` target to a549's gene-keyed `h2b`. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_vscyto3daug/checkpoints/epoch=28-step=75400-loss=0.776.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: FNet3DVSAug_PRED_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__a549_mantis_h2b_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__a549_mantis_h2b_zikv.yml new file mode 100644 index 000000000..1245674b7 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__a549_mantis_h2b_zikv.yml @@ -0,0 +1,54 @@ +# FNet3DVSAug predict (Phase 15): nucleus trained on iPSC, predicting against +# a549-mantis-h2b-zikv test. +# Arm B of the FNet3D patch-vs-augmentation ablation: the same larger +# 384^2 patch plus the full VSCyto3D augmentation stack. Arm A vs Arm B is the +# clean augmentation comparison (identical geometry, batch and precision). +# +# Pinned to the BEST val-loss checkpoint (epoch 28, loss/validate=0.776), NOT +# `last.ckpt`: this arm's val loss rises after an early minimum, and checkpoint +# writes also stopped ~3 h before the job ended, so `last.ckpt` is neither the +# best nor the final state. +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` +# target_id from targets/nucleus.yml so the resolver finds the h2b target. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv + model_name: fnet3d_vscyto3daug + experiment_id: nucleus__ipsc_confocal__fnet3d_vscyto3daug__a549_mantis_h2b_zikv + # Override the iPSC-side `nucleus` target to a549's gene-keyed `h2b`. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_vscyto3daug/checkpoints/epoch=28-step=75400-loss=0.776.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: FNet3DVSAug_PRED_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..e2394be6d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,49 @@ +# FNet3DVSAug predict (Phase 15): nucleus trained on iPSC, predicting against +# ipsc_confocal test_cropped. +# Arm B of the FNet3D patch-vs-augmentation ablation: the same larger +# 384^2 patch plus the full VSCyto3D augmentation stack. Arm A vs Arm B is the +# clean augmentation comparison (identical geometry, batch and precision). +# +# Pinned to the BEST val-loss checkpoint (epoch 28, loss/validate=0.776), NOT +# `last.ckpt`: this arm's val loss rises after an early minimum, and checkpoint +# writes also stopped ~3 h before the job ended, so `last.ckpt` is neither the +# best nor the final state. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: fnet3d_vscyto3daug + experiment_id: nucleus__ipsc_confocal__fnet3d_vscyto3daug__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_vscyto3daug/checkpoints/epoch=28-step=75400-loss=0.776.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/ipsc/prediction.zarr + +launcher: + job_name: FNet3DVSAug_PRED_NUCL + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/train.yml new file mode 100644 index 000000000..2347b011b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/train.yml @@ -0,0 +1,86 @@ +# FNet3D "same-augmentations" OOD ablation on nucleus (Nuclei channel of +# cell.zarr) — AICS iPSC confocal. Identical to the fnet3d_paper iPSC +# nucleus fit except the augmentation stack: this leaf composes +# data_overlays/fnet3d_vscyto3daug_fit.yml (VSCyto3D augmentations adapted +# to FNet3D's Z=32 geometry) instead of fnet3d_paper_fit.yml. The data +# overlay keys norm/aug/val on Structure; nucleus target_channel is Nuclei, +# so we list-replace those three lists here to re-key them. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/fnet3d_vscyto3daug_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: ipsc_confocal + model_name: fnet3d_vscyto3daug + experiment_id: nucleus__ipsc_confocal__fnet3d_vscyto3daug + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Nuclei] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [32, 600, 600] + num_samples: 4 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Phase3D, Nuclei] + roi_size: [32, 384, 384] + +trainer: + # Switch off the fnet3d_paper 32-true default: bf16-mixed halves the + # 384x384x32 activation footprint. MSE loss is immune to the bf16-SSIM + # cancellation issue. Must match fnet3d_bigpatch (Arm A) for a clean + # augmentation-only comparison. + precision: bf16-mixed + logger: + init_args: + name: FNet3D_VSAug_iPSC_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_vscyto3daug + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_vscyto3daug/checkpoints + +launcher: + job_name: FNet3DVSAug_iPSC_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/fnet3d_vscyto3daug + # 384x384x32 at bf16-mixed measured ~41GB GPU on the bigpatch arm, so an + # 80GB card (H100) fits with room; allow h100|h200 to schedule sooner. The + # vscyto3d aug stack (affine grid_sample + intensity) runs somewhat higher + # but still well under 80GB. cell.zarr-backed preload pushes MaxVMSize past + # the shared 256G cap; mem 512G matches the fnet3d iPSC headroom. + sbatch: + constraint: "h100|h200" + mem: "512G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/train_smoke.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/train_smoke.yml new file mode 100644 index 000000000..3fa3ee097 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal/train_smoke.yml @@ -0,0 +1,66 @@ +# Smoke sibling of nucleus/fnet3d_vscyto3daug/ipsc_confocal/train.yml. +# Verifies the VSCyto3D augmentation pipeline (600->384 weighted crop + +# affine + intensity stack) runs on the real iPSC cell.zarr at FNet3D's +# Z=32, that a bf16-mixed batch of 8 fits a single H200, and that train + +# val forward/backward produce finite MSE — before the real batch launches. +# Scratch run_root, no logger, no checkpoints, lazy read (mmap_preload +# false) for a fast start, 30 steps, bounded 30-min wall. +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/fnet3d_vscyto3daug_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: ipsc_confocal + model_name: fnet3d_vscyto3daug + experiment_id: nucleus__ipsc_confocal__fnet3d_vscyto3daug__smoke + +trainer: + precision: bf16-mixed + max_steps: 30 + limit_val_batches: 2 + logger: false + callbacks: [] + +data: + init_args: + mmap_preload: false + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Nuclei] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [32, 600, 600] + num_samples: 4 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Phase3D, Nuclei] + roi_size: [32, 384, 384] + +launcher: + job_name: FNet3DVSAug_SMOKE + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/_smoke/fnet3d_vscyto3daug_ipsc_nucleus + sbatch: + constraint: h200 + mem: "128G" + time: "00:30:00" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..e5c94bdb5 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/predict__a549_mantis_denv.yml @@ -0,0 +1,66 @@ +# FNet3DVSAugBF predict: nucleus trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_h2b_denv. +# +# Arm B of the FNet3D patch-vs-augmentation ablation: the same larger 384^2 patch +# plus the full VSCyto3D augmentation stack, now on brightfield input. +# +# Brightfield-input arm of nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__*.yml. Every +# field is copied from that phase baseline; the only differences are the input +# channel (dataset_ref.source_channel + the normalization key), the checkpoint, +# and the on-disk identity (train_set token `ipsc__bf`). +# +# Checkpoint is the loss/validate-monitored best, 0.6856 at epoch 51 of 0-76, +# read from the monitored ModelCheckpoint callback in last.ckpt -- that file also +# carries an unmonitored `latest-*` callback whose best_model_path is just the +# final step (epoch 76). The fit ran to `max_steps=200000` and val loss drifts up +# after the minimum, so `last.ckpt` is the wrong pin here as on the phase arm. +# Not directly comparable to the phase baseline's 0.776 (epoch 28): that +# run's checkpoint writes halted hours before it ended, so its retained best is a +# floor, not its true minimum. +# +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side +# `nucleus` target_id from targets/nucleus.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal_brightfield + predict_set: a549_mantis_h2b_denv + model_name: fnet3d_vscyto3daug + experiment_id: nucleus__ipsc_confocal_brightfield__fnet3d_vscyto3daug__a549_mantis_h2b_denv + dataset_ref: + source_channel: Brightfield + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_vscyto3daug/checkpoints/epoch=51-step=135200-loss=0.686.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc__bf/a549__denv/prediction.zarr + +launcher: + job_name: FNet3DVSAugBF_PRED_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc__bf/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..c51f3a79c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/predict__a549_mantis_mock.yml @@ -0,0 +1,66 @@ +# FNet3DVSAugBF predict: nucleus trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_h2b_mock. +# +# Arm B of the FNet3D patch-vs-augmentation ablation: the same larger 384^2 patch +# plus the full VSCyto3D augmentation stack, now on brightfield input. +# +# Brightfield-input arm of nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__*.yml. Every +# field is copied from that phase baseline; the only differences are the input +# channel (dataset_ref.source_channel + the normalization key), the checkpoint, +# and the on-disk identity (train_set token `ipsc__bf`). +# +# Checkpoint is the loss/validate-monitored best, 0.6856 at epoch 51 of 0-76, +# read from the monitored ModelCheckpoint callback in last.ckpt -- that file also +# carries an unmonitored `latest-*` callback whose best_model_path is just the +# final step (epoch 76). The fit ran to `max_steps=200000` and val loss drifts up +# after the minimum, so `last.ckpt` is the wrong pin here as on the phase arm. +# Not directly comparable to the phase baseline's 0.776 (epoch 28): that +# run's checkpoint writes halted hours before it ended, so its retained best is a +# floor, not its true minimum. +# +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side +# `nucleus` target_id from targets/nucleus.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal_brightfield + predict_set: a549_mantis_h2b_mock + model_name: fnet3d_vscyto3daug + experiment_id: nucleus__ipsc_confocal_brightfield__fnet3d_vscyto3daug__a549_mantis_h2b_mock + dataset_ref: + source_channel: Brightfield + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_vscyto3daug/checkpoints/epoch=51-step=135200-loss=0.686.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc__bf/a549__mock/prediction.zarr + +launcher: + job_name: FNet3DVSAugBF_PRED_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc__bf/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..08b8b887d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/predict__a549_mantis_zikv.yml @@ -0,0 +1,66 @@ +# FNet3DVSAugBF predict: nucleus trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against a549_mantis_h2b_zikv. +# +# Arm B of the FNet3D patch-vs-augmentation ablation: the same larger 384^2 patch +# plus the full VSCyto3D augmentation stack, now on brightfield input. +# +# Brightfield-input arm of nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__*.yml. Every +# field is copied from that phase baseline; the only differences are the input +# channel (dataset_ref.source_channel + the normalization key), the checkpoint, +# and the on-disk identity (train_set token `ipsc__bf`). +# +# Checkpoint is the loss/validate-monitored best, 0.6856 at epoch 51 of 0-76, +# read from the monitored ModelCheckpoint callback in last.ckpt -- that file also +# carries an unmonitored `latest-*` callback whose best_model_path is just the +# final step (epoch 76). The fit ran to `max_steps=200000` and val loss drifts up +# after the minimum, so `last.ckpt` is the wrong pin here as on the phase arm. +# Not directly comparable to the phase baseline's 0.776 (epoch 28): that +# run's checkpoint writes halted hours before it ended, so its retained best is a +# floor, not its true minimum. +# +# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side +# `nucleus` target_id from targets/nucleus.yml so the resolver finds it. + +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal_brightfield + predict_set: a549_mantis_h2b_zikv + model_name: fnet3d_vscyto3daug + experiment_id: nucleus__ipsc_confocal_brightfield__fnet3d_vscyto3daug__a549_mantis_h2b_zikv + dataset_ref: + source_channel: Brightfield + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_vscyto3daug/checkpoints/epoch=51-step=135200-loss=0.686.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc__bf/a549__zikv/prediction.zarr + +launcher: + job_name: FNet3DVSAugBF_PRED_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc__bf/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/predict__ipsc_confocal.yml new file mode 100644 index 000000000..82414a632 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/predict__ipsc_confocal.yml @@ -0,0 +1,62 @@ +# FNet3DVSAugBF predict: nucleus trained on ipsc_confocal_brightfield, BRIGHTFIELD input, +# predicting against ipsc_confocal. +# +# Arm B of the FNet3D patch-vs-augmentation ablation: the same larger 384^2 patch +# plus the full VSCyto3D augmentation stack, now on brightfield input. +# +# Brightfield-input arm of nucleus/fnet3d_vscyto3daug/ipsc_confocal/predict__*.yml. Every +# field is copied from that phase baseline; the only differences are the input +# channel (dataset_ref.source_channel + the normalization key), the checkpoint, +# and the on-disk identity (train_set token `ipsc__bf`). +# +# Checkpoint is the loss/validate-monitored best, 0.6856 at epoch 51 of 0-76, +# read from the monitored ModelCheckpoint callback in last.ckpt -- that file also +# carries an unmonitored `latest-*` callback whose best_model_path is just the +# final step (epoch 76). The fit ran to `max_steps=200000` and val loss drifts up +# after the minimum, so `last.ckpt` is the wrong pin here as on the phase arm. +# Not directly comparable to the phase baseline's 0.776 (epoch 28): that +# run's checkpoint writes halted hours before it ended, so its retained best is a +# floor, not its true minimum. + +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal_brightfield + predict_set: ipsc_confocal + model_name: fnet3d_vscyto3daug + experiment_id: nucleus__ipsc_confocal_brightfield__fnet3d_vscyto3daug__ipsc_confocal + dataset_ref: + source_channel: Brightfield + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_vscyto3daug/checkpoints/epoch=51-step=135200-loss=0.686.ckpt + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc__bf/ipsc/prediction.zarr + +launcher: + job_name: FNet3DVSAugBF_PRED_NUCL + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/fnet3d_vscyto3daug/ipsc__bf/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/train.yml new file mode 100644 index 000000000..70a2e8500 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/fnet3d_vscyto3daug/ipsc_confocal_brightfield/train.yml @@ -0,0 +1,103 @@ +# FNet3D "same-augmentations" ablation on nucleus (Nuclei channel of +# cell.zarr) — AICS iPSC confocal, BRIGHTFIELD input. +# +# This leaf exists to BREAK A CONFOUND. Every brightfield arm shipped so far +# composes data_overlays/fnet3d_paper_fit.yml, i.e. the 64x64-patch, +# flip-only recipe that sec:fnet_patch_aug_ablation shows is itself the +# cause of FNet3D's iPSC->A549 collapse. So the one case where brightfield +# appeared to beat phase (FNet3D iPSC->A549, 7-2-1) is exactly the case +# where the phase arm is degenerate for reasons that have nothing to do +# with the input channel — and CELL-Diff3D, which carries a healthy recipe, +# gained nothing from brightfield at all. +# +# Pairing with the three leaves that already exist completes a 2x3 grid and +# makes "does brightfield help?" separable from "is the recipe broken?": +# +# | fnet3d_paper | fnet3d_bigpatch | fnet3d_vscyto3daug +# Phase3D | shipped | shipped | shipped +# Brightfield| shipped | THIS leaf's | THIS leaf +# | | sibling | +# +# Everything except the input channel is verbatim from +# nucleus/fnet3d_vscyto3daug/ipsc_confocal/train.yml, so a bf-vs-phase +# delta at this rung attributes to the input and nothing else. +# +# The data overlay keys norm/aug/val on Phase3D + Structure; this arm's +# source is Brightfield and the nucleus target_channel is Nuclei, so all +# three lists are re-keyed here (deep_merge replaces lists wholesale). +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal_brightfield.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/fnet3d_vscyto3daug_fit.yml + - ../../../_internal/shared/model/model_overlays/fnet3d_paper_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_gpu_any_long.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + train_set: ipsc_confocal_brightfield + model_name: fnet3d_vscyto3daug + experiment_id: nucleus__ipsc_confocal_brightfield__fnet3d_vscyto3daug + +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Brightfield] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Nuclei] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Brightfield, Nuclei] + w_key: Nuclei + spatial_size: [32, 600, 600] + num_samples: 4 + val_augmentations: + - class_path: viscy_transforms.CenterSpatialCropd + init_args: + keys: [Brightfield, Nuclei] + roi_size: [32, 384, 384] + +trainer: + # bf16-mixed halves the 384x384x32 activation footprint; MSE loss is immune + # to the bf16-SSIM cancellation issue. Must match the phase sibling. + precision: bf16-mixed + logger: + init_args: + name: FNet3D_VSAug_iPSCbf_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_vscyto3daug + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_vscyto3daug/checkpoints + +launcher: + job_name: FNet3DVSAugBF_iPSC_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc__bf/nucleus/fnet3d_vscyto3daug + # Same envelope as the phase sibling: 384x384x32 at bf16-mixed measured + # ~41GB on the bigpatch arm, so an 80GB card fits with room. cell.zarr-backed + # preload pushes MaxVMSize past the shared 256G cap; mem 512G matches the + # fnet3d iPSC headroom. + sbatch: + constraint: "h100|h200" + mem: "512G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..862cc6cd0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,72 @@ +# pix2pix2d predict: nucleus trained on a549_mantis, tested on A549 mantis denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/nucleus.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_denv + model_name: pix2pix2d_unetvit + experiment_id: nucleus__a549_mantis__pix2pix2d_unetvit__a549_mantis_h2b_denv + # A549 keys this organelle by gene; override the iPSC-side target + # from the target fragment so the resolver finds it on the A549 set. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix2d_unetvit/checkpoints/epoch=38-step=11700-loss=2.161.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/a549__denv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_A549_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..df04059f3 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,72 @@ +# pix2pix2d predict: nucleus trained on a549_mantis, tested on A549 mantis mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/nucleus.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_mock + model_name: pix2pix2d_unetvit + experiment_id: nucleus__a549_mantis__pix2pix2d_unetvit__a549_mantis_h2b_mock + # A549 keys this organelle by gene; override the iPSC-side target + # from the target fragment so the resolver finds it on the A549 set. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix2d_unetvit/checkpoints/epoch=38-step=11700-loss=2.161.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/a549__mock/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_A549_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..7288e473b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,72 @@ +# pix2pix2d predict: nucleus trained on a549_mantis, tested on A549 mantis zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/nucleus.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_zikv + model_name: pix2pix2d_unetvit + experiment_id: nucleus__a549_mantis__pix2pix2d_unetvit__a549_mantis_h2b_zikv + # A549 keys this organelle by gene; override the iPSC-side target + # from the target fragment so the resolver finds it on the A549 set. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix2d_unetvit/checkpoints/epoch=38-step=11700-loss=2.161.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/a549__zikv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_A549_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..9ab074959 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: nucleus trained on a549_mantis, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/nucleus.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit + experiment_id: nucleus__a549_mantis__pix2pix2d_unetvit__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix2d_unetvit/checkpoints/epoch=38-step=11700-loss=2.161.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/ipsc/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_A549_NUCL_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/train.yml new file mode 100644 index 000000000..41e1970be --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/a549_mantis/train.yml @@ -0,0 +1,102 @@ +# pix2pix2d_unetvit (UNetViT generator + multi-scale PatchGAN, run +# Z-preserving at Z=1) fit on nucleus (Nuclei channel) — A549 mantis-lightsheet pooled (mock + DENV + ZIKV), +# in-focus 2D track. Mirror of the 3D +# nucleus/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml leaf, +# flattened onto the offline 5-plane in-focus slab store (z_window_size=1 +# emits one in-focus window per plane). +# +# ⚠ Mirrors train_4gpu_modernized.yml, NOT the stale sibling train.yml. The +# published pix2pix3d rows came from the modernized "Run D" recipe — the +# checkpoints carry loss_type='nonsat', lr 2e-4/2e-4, r1_gamma=10, +# ema_kimg=10, lecam_gamma=0.3, lambda_l1=10 and 201 generator_ema.* tensors +# — while train.yml still composes the LSGAN baseline overlay. All of Run D is +# baked into model_overlays/pix2pix2d_unetvit_fit.yml, so unlike the 3D leaves +# this file repeats none of it. +# +# The 3D leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus store. +# The 2D track reads the `_focus.zarr` slab instead, so the resolver is +# disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field co-declared +# with a full dataset_ref. +# +# The train_set fragment supplies data.class_path (HCSDataModule) plus +# split_ratio / mmap_preload / scratch_dir. targets/nucleus.yml supplies the +# NormalizeSampled(fov_statistics) normalization the pix2pix leaves use +# (mean/std on Phase3D, median/iqr on the target); only its RandWeightedCropd +# is list-replaced below, flattened [13,624,624] -> [1,624,624]. + +base: + - ../../../_internal/shared/model/train_sets/a549_mantis.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + gene: Nuclei + target: nucleus + target_id: nucleus + train_set: a549_mantis + model_name: pix2pix2d_unetvit + experiment_id: nucleus__a549_mantis__pix2pix2d_unetvit + # Disable the manifest resolver: the 2D track reads the offline focus store, + # not the manifest-registered non-focus store. + dataset_ref: null + +data: + init_args: + # pooled A549 in-focus slab store (Nuclei channel) — resolver disabled above. + source_channel: Phase3D + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + # Flatten the target fragment's [13, 624, 624] weighted crop to Z=1. + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [1, 624, 624] + num_samples: 2 + +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_A549_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix2d_unetvit + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + # monitor loss/validate_ema, matching the 3D Run-D leaves: ema_kimg is set, + # so the EMA generator is the one the recipe selects on and the one predict + # reports. Monitoring the raw loss/validate would pin a different epoch. + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix2d_unetvit/checkpoints + +launcher: + job_name: pix2pix2d_unetvit_A549_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix2d_unetvit + sbatch: + # Narrow OFF the hardware_4gpu h100|h200 default, the opposite of the 3D + # leaf. 3D needed h200 because the GAN OOMs 80 GB at Z=8; measured at Z=1 + # on an A40 (44.7 GiB) peak is 13.3 GiB/rank at batch_size 4, so the 48 GB + # cards have 3x headroom and reserving Hopper for this would be queue + # squatting. The profile documents this opt-out explicitly. + constraint: "a40|a6000|l40s|h100|h200" + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D store + # (~1/4 the Z), so the profile's 512G mmap_preload headroom is inherited 3D + # scale. Set in the LEAF BODY because launcher_profiles compose after model + # overlays and would otherwise win. + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..fe50e00be --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,72 @@ +# pix2pix2d predict: nucleus trained on ipsc_confocal, tested on A549 mantis denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/nucleus.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv + model_name: pix2pix2d_unetvit + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit__a549_mantis_h2b_denv + # A549 keys this organelle by gene; override the iPSC-side target + # from the target fragment so the resolver finds it on the A549 set. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit/checkpoints/epoch=22-step=11500-loss=0.712.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/a549__denv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..6493d5866 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,72 @@ +# pix2pix2d predict: nucleus trained on ipsc_confocal, tested on A549 mantis mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/nucleus.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock + model_name: pix2pix2d_unetvit + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit__a549_mantis_h2b_mock + # A549 keys this organelle by gene; override the iPSC-side target + # from the target fragment so the resolver finds it on the A549 set. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit/checkpoints/epoch=22-step=11500-loss=0.712.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/a549__mock/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..b70bcc211 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,72 @@ +# pix2pix2d predict: nucleus trained on ipsc_confocal, tested on A549 mantis zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/nucleus.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv + model_name: pix2pix2d_unetvit + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit__a549_mantis_h2b_zikv + # A549 keys this organelle by gene; override the iPSC-side target + # from the target fragment so the resolver finds it on the A549 set. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit/checkpoints/epoch=22-step=11500-loss=0.712.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/a549__zikv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..fce6c9365 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: nucleus trained on ipsc_confocal, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/nucleus.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit/checkpoints/epoch=22-step=11500-loss=0.712.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/ipsc/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_NUCL_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/train.yml new file mode 100644 index 000000000..706cc6c49 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/ipsc_confocal/train.yml @@ -0,0 +1,102 @@ +# pix2pix2d_unetvit (UNetViT generator + multi-scale PatchGAN, run +# Z-preserving at Z=1) fit on nucleus (Nuclei channel) — AICS iPSC confocal, +# in-focus 2D track. Mirror of the 3D +# nucleus/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml leaf, +# flattened onto the offline 5-plane in-focus slab store (z_window_size=1 +# emits one in-focus window per plane). +# +# ⚠ Mirrors train_4gpu_modernized.yml, NOT the stale sibling train.yml. The +# published pix2pix3d rows came from the modernized "Run D" recipe — the +# checkpoints carry loss_type='nonsat', lr 2e-4/2e-4, r1_gamma=10, +# ema_kimg=10, lecam_gamma=0.3, lambda_l1=10 and 201 generator_ema.* tensors +# — while train.yml still composes the LSGAN baseline overlay. All of Run D is +# baked into model_overlays/pix2pix2d_unetvit_fit.yml, so unlike the 3D leaves +# this file repeats none of it. +# +# The 3D leaf resolves data_path/source_channel/target_channel from the +# manifest via benchmark.dataset_ref, which points at the NON-focus store. +# The 2D track reads the `_focus.zarr` slab instead, so the resolver is +# disabled here (dataset_ref: null) and the three data fields are declared +# inline — the resolver hook raises on any data.init_args field co-declared +# with a full dataset_ref. +# +# The train_set fragment supplies data.class_path (HCSDataModule) plus +# split_ratio / mmap_preload / scratch_dir. targets/nucleus.yml supplies the +# NormalizeSampled(fov_statistics) normalization the pix2pix leaves use +# (mean/std on Phase3D, median/iqr on the target); only its RandWeightedCropd +# is list-replaced below, flattened [13,624,624] -> [1,624,624]. + +base: + - ../../../_internal/shared/model/train_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + gene: Nuclei + target: nucleus + target_id: nucleus + train_set: ipsc_confocal + model_name: pix2pix2d_unetvit + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit + # Disable the manifest resolver: the 2D track reads the offline focus store, + # not the manifest-registered non-focus store. + dataset_ref: null + +data: + init_args: + # aics-hipsc in-focus slab store (Nuclei channel) — resolver disabled above. + source_channel: Phase3D + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + # Flatten the target fragment's [13, 624, 624] weighted crop to Z=1. + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [1, 624, 624] + num_samples: 2 + +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_iPSC_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + # monitor loss/validate_ema, matching the 3D Run-D leaves: ema_kimg is set, + # so the EMA generator is the one the recipe selects on and the one predict + # reports. Monitoring the raw loss/validate would pin a different epoch. + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit/checkpoints + +launcher: + job_name: pix2pix2d_unetvit_iPSC_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit + sbatch: + # Narrow OFF the hardware_4gpu h100|h200 default, the opposite of the 3D + # leaf. 3D needed h200 because the GAN OOMs 80 GB at Z=8; measured at Z=1 + # on an A40 (44.7 GiB) peak is 13.3 GiB/rank at batch_size 4, so the 48 GB + # cards have 3x headroom and reserving Hopper for this would be queue + # squatting. The profile documents this opt-out explicitly. + constraint: "a40|a6000|l40s|h100|h200" + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D store + # (~1/4 the Z), so the profile's 512G mmap_preload headroom is inherited 3D + # scale. Set in the LEAF BODY because launcher_profiles compose after model + # overlays and would otherwise win. + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..2ed6df7cd --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,72 @@ +# pix2pix2d predict: nucleus trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis denv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/nucleus.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_denv + model_name: pix2pix2d_unetvit + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit__a549_mantis_h2b_denv + # A549 keys this organelle by gene; override the iPSC-side target + # from the target fragment so the resolver finds it on the A549 set. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix2d_unetvit/checkpoints/epoch=18-step=15200-loss=1.271.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/a549__denv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_JOINT_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..90a1ac3d5 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,72 @@ +# pix2pix2d predict: nucleus trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis mock. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/nucleus.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_mock + model_name: pix2pix2d_unetvit + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit__a549_mantis_h2b_mock + # A549 keys this organelle by gene; override the iPSC-side target + # from the target fragment so the resolver finds it on the A549 set. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix2d_unetvit/checkpoints/epoch=18-step=15200-loss=1.271.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/a549__mock/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_JOINT_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..3365407bd --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,72 @@ +# pix2pix2d predict: nucleus trained on joint_ipsc_confocal_a549_mantis, tested on A549 mantis zikv. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/nucleus.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_zikv + model_name: pix2pix2d_unetvit + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit__a549_mantis_h2b_zikv + # A549 keys this organelle by gene; override the iPSC-side target + # from the target fragment so the resolver finds it on the A549 set. + dataset_ref: + target: h2b + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix2d_unetvit/checkpoints/epoch=18-step=15200-loss=1.271.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/a549__zikv/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_JOINT_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..d08f63468 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,68 @@ +# pix2pix2d predict: nucleus trained on joint_ipsc_confocal_a549_mantis, tested on iPSC confocal. +# In-focus 2D track. The Z=1 checkpoint predicts over the FULL-Z 3D test store +# with z_window_size=1 (pix2pix2d_unetvit_predict overlay), emitting one window +# per z-plane -> a full-extent prediction store the existing focus-aware eval consumes +# unchanged. +# +# Source normalization is NormalizeSampled(Phase3D, fov_statistics, mean/std), +# reproducing the pix2pix2d fit exactly — the fit inherits it from +# targets/nucleus.yml and a MinMax source here would silently degrade every +# prediction. The target-inherited RandWeightedCropd is cleared: predict has no +# CPU augmentations. +# +# predict_method=sliding_window and predict_overlap Z=0 are overlay-owned; see +# model_overlays/pix2pix2d_unetvit_predict.yml for why (the lateral ViT 512x512 +# limit, and Z patch 1) -- it states the per-test-set caveat this leaf cannot. +# +# No z_reduction: at z_window_size=1 each plane comes from exactly one window, so +# there is nothing to reduce across (the 3D pix2pix leaves need `center` only +# because their 8-plane windows overlap). +# +# Fit completion verified from the run log, not a checkpoint filename: +# `Trainer.fit` stopped: `max_epochs=40` reached. +# Baked checkpoint is that run's best loss/validate_ema epoch. +base: + - ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml + - ../../../_internal/shared/model/targets/nucleus.yml + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml + - ../../../_internal/shared/model/launcher_profiles/mode_predict.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit__ipsc_confocal + +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix2d_unetvit/checkpoints/epoch=18-step=15200-loss=1.271.ckpt + +data: + init_args: + # 2D benchmark (focus2d.halfwidth=1): predict only the 3-plane focus slab of each + # FOV/timepoint listed in this plane file (precompute-gt build.focus_planes, resolved + # exactly as the focus2d eval resolves it); every other plane of the full-extent store + # stays empty. Set null to predict every plane. + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] + +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/ipsc/prediction.zarr + +launcher: + job_name: pix2pix2D_PRED_JOINT_NUCL_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..587cc7ace --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,170 @@ +# pix2pix2d_unetvit (UNetViT generator + multi-scale PatchGAN, run +# Z-preserving at Z=1) fit on nucleus (Nuclei channel) — joint ipsc_confocal + a549_mantis pooled, +# in-focus 2D track. Mirror of the 3D +# nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml leaf, +# flattened onto the offline 5-plane in-focus slab store (z_window_size=1 +# emits one in-focus window per plane). +# +# ⚠ Mirrors train_4gpu_modernized.yml, NOT the stale sibling train.yml. The +# published pix2pix3d rows came from the modernized "Run D" recipe — the +# checkpoints carry loss_type='nonsat', lr 2e-4/2e-4, r1_gamma=10, +# ema_kimg=10, lecam_gamma=0.3, lambda_l1=10 and 201 generator_ema.* tensors +# — while train.yml still composes the LSGAN baseline overlay. All of Run D is +# baked into model_overlays/pix2pix2d_unetvit_fit.yml, so unlike the 3D leaves +# this file repeats none of it. +# +# BatchedConcatDataModule + two explicit HCSDataModule children; only +# model_overlays/pix2pix2d_unetvit_fit.yml is composed (the data block is +# authored inline here, not via data_overlays). +# +# Normalization is NormalizeSampled (fov_statistics), matching the single-set +# pix2pix2d leaves — divergent from the celldiff joint, which uses +# MinMaxSampled. Per-organelle prior is to keep joint and single-set +# normalizations identical so ablations are apples-to-apples. +# +# batch_size 2 here, NOT the single-set 4: BatchedConcatDataModule's +# train_dataloader uses batch_size as-is, while HCSDataModule divides by +# RandWeightedCropd num_samples. 2 indices * 2 num_samples = 4 GPU samples per +# rank, x 4 DDP ranks = the same 16 samples/step as the 3D arm. +base: + - ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml + - ../../../_internal/shared/model/launcher_profiles/mode_fit.yml + - ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml + - ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml + +benchmark: + task: virtual_staining + organelle: nucleus + gene: Nuclei + target: nucleus + target_id: nucleus + train_set: joint_ipsc_confocal_a549_mantis + model_name: pix2pix2d_unetvit + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit + +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_JOINT_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix2d_unetvit + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + # monitor loss/validate_ema, matching the 3D Run-D leaves: ema_kimg is set, + # so the EMA generator is the one the recipe selects on and the one predict + # reports. Monitoring the raw loss/validate would pin a different epoch. + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix2d_unetvit/checkpoints + +_hcs_init_args: &hcs_init_args + source_channel: Phase3D + target_channel: Nuclei + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: [512, 512] + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Phase3D] + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: [Nuclei] + level: fov_statistics + subtrahend: median + divisor: iqr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: [Phase3D, Nuclei] + w_key: Nuclei + spatial_size: [1, 624, 624] + num_samples: 2 + gpu_augmentations: + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: [source, target] + prob: 0.8 + rotate_range: [0, 0, 0] + shear_range: [0.0, 0.05, 0.05] + scale_range: [[1, 1], [0.5, 1.5], [0.5, 1.5]] + safe_crop_size: [1, 512, 512] + safe_crop_coverage: 0.9 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: [source] + prob: 0.5 + gamma: [0.8, 1.2] + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: [source] + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: [source] + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: [source] + prob: 0.5 + sigma_x: [0.25, 0.75] + sigma_y: [0.25, 0.75] + sigma_z: [0, 0] + val_gpu_augmentations: + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: [source, target] + roi_size: [1, 512, 512] + +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + # ipsc_confocal — aics-hipsc in-focus slab store (Nuclei channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + # a549_mantis — pooled A549 in-focus slab store (Nuclei channel) + - class_path: viscy_data.hcs.HCSDataModule + init_args: + <<: *hcs_init_args + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + +launcher: + job_name: pix2pix2d_unetvit_JOINT_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix2d_unetvit + sbatch: + # Narrow OFF the hardware_4gpu h100|h200 default, the opposite of the 3D + # leaf. 3D needed h200 because the GAN OOMs 80 GB at Z=8; measured at Z=1 + # on an A40 (44.7 GiB) peak is 13.3 GiB/rank at batch_size 4, so the 48 GB + # cards have 3x headroom and reserving Hopper for this would be queue + # squatting. The profile documents this opt-out explicitly. + constraint: "a40|a6000|l40s|h100|h200" + # 128G: the in-focus slab store is a 5-plane slice of the full-Z 3D store + # (~1/4 the Z), so the profile's 512G mmap_preload headroom is inherited 3D + # scale. Set in the LEAF BODY because launcher_profiles compose after model + # overlays and would otherwise win. + mem: "128G" diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..59f10abdc --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,45 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv + model_name: pix2pix2d_unetvit_seed1 + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit_seed1__a549_mantis_h2b_denv + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_seed1/ipsc/a549__denv/prediction.zarr +launcher: + job_name: pix2pix2D_PRED_NUCL_ON_A549_DENV_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_seed1/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..7265727bb --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,45 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock + model_name: pix2pix2d_unetvit_seed1 + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit_seed1__a549_mantis_h2b_mock + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_seed1/ipsc/a549__mock/prediction.zarr +launcher: + job_name: pix2pix2D_PRED_NUCL_ON_A549_MOCK_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_seed1/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..8ad0b89c0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,45 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv + model_name: pix2pix2d_unetvit_seed1 + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit_seed1__a549_mantis_h2b_zikv + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_seed1/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: pix2pix2D_PRED_NUCL_ON_A549_ZIKV_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_seed1/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..23fed38c5 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,43 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (predict) of the baseline leaf nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml. +# Inference is identical to the baseline's; only the checkpoint, store and names differ. +# ckpt_path is a PLACEHOLDER (last.ckpt): submit with `--ckpt best`, re-bake afterwards. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit_seed1 + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit_seed1__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_seed1/checkpoints/last.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_seed1/ipsc/ipsc/prediction.zarr +launcher: + job_name: pix2pix2D_PRED_NUCL_ON_IPSC_seed1 + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_seed1/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/train.yml new file mode 100644 index 000000000..d8fd8f8b1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_seed1/ipsc_confocal/train.yml @@ -0,0 +1,65 @@ +# GENERATED by applications/dynacell/tools/generate_spotlight_v2_leaves.py -- edit the +# generator, not this file (plan: ~/.claude/plans/spotlight-v2.md). +# Spotlight-v2 `seed1` arm (fit) of the baseline leaf nucleus/pix2pix2d_unetvit/ipsc_confocal/train.yml. +# Recipe delta vs that leaf: seed_everything: 1. +# Everything else, and the rationale for it, is the baseline leaf's. +base: +- ../../../_internal/shared/model/train_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + gene: Nuclei + target: nucleus + target_id: nucleus + train_set: ipsc_confocal + model_name: pix2pix2d_unetvit_seed1 + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit_seed1 + dataset_ref: null +data: + init_args: + source_channel: Phase3D + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Nuclei + w_key: Nuclei + spatial_size: + - 1 + - 624 + - 624 + num_samples: 2 +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_iPSC_NUCL_seed1 + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_seed1 + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: epoch={epoch}-step={step}-loss={loss/validate_ema:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_seed1/checkpoints +launcher: + job_name: pix2pix2d_unetvit_iPSC_NUCL_seed1 + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_seed1 + sbatch: + constraint: a40|a6000|l40s|h100|h200 + mem: 128G +seed_everything: 1 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..24e804ea0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch` arm (predict) of nucleus/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_denv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_denv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: nucleus__a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_h2b_denv + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix2d_unetvit_wmatch/checkpoints/epoch=35-step=10800-loss=2.055.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/a549/a549__denv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_A549_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..9026d8b0b --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch` arm (predict) of nucleus/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_mock.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_mock + model_name: pix2pix2d_unetvit_wmatch + experiment_id: nucleus__a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_h2b_mock + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix2d_unetvit_wmatch/checkpoints/epoch=35-step=10800-loss=2.055.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/a549/a549__mock/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_A549_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..4d92861de --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch` arm (predict) of nucleus/pix2pix2d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: a549_mantis_h2b_zikv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: nucleus__a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_h2b_zikv + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix2d_unetvit_wmatch/checkpoints/epoch=35-step=10800-loss=2.055.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/a549/a549__zikv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_A549_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..41d4cbca2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of nucleus/pix2pix2d_unetvit/a549_mantis/predict__ipsc_confocal.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: a549_mantis + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch + experiment_id: nucleus__a549_mantis__pix2pix2d_unetvit_wmatch__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix2d_unetvit_wmatch/checkpoints/epoch=35-step=10800-loss=2.055.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/a549/ipsc/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_A549_NUCL_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/train.yml new file mode 100644 index 000000000..34c8303c9 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/a549_mantis/train.yml @@ -0,0 +1,69 @@ +# pix2pix2d `wmatch` arm (fit) of nucleus/pix2pix2d_unetvit/a549_mantis/train.yml. +# Recipe delta: warmup_steps 8500 -> 1181. Run-D's 8500-batch warmup is +# 19.7 % of the matching 3D fit (43200 batches); this 2D fit runs 6000, so +# round(8500 * 6000 / 43200) keeps the same schedule shape. The baseline's absolute 8500 +# left 5 of 12 2D fits still warming up at their last step (wandb lr-AdamW, 2026-10-22). +# Everything else, and the rationale for it, is the baseline leaf's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_fit_leaves.py. +base: +- ../../../_internal/shared/model/train_sets/a549_mantis.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + gene: Nuclei + target: nucleus + target_id: nucleus + train_set: a549_mantis + model_name: pix2pix2d_unetvit_wmatch + experiment_id: nucleus__a549_mantis__pix2pix2d_unetvit_wmatch + dataset_ref: null +data: + init_args: + source_channel: Phase3D + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Nuclei + w_key: Nuclei + spatial_size: + - 1 + - 624 + - 624 + num_samples: 2 +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_wmatch_A549_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix2d_unetvit_wmatch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: epoch={epoch}-step={step}-loss={loss/validate_ema:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix2d_unetvit_wmatch/checkpoints +launcher: + job_name: pix2pix2d_unetvit_wmatch_A549_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix2d_unetvit_wmatch + sbatch: + constraint: a40|a6000|l40s|h100|h200 + mem: 128G +model: + init_args: + warmup_steps: 1181 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..6ccb905a3 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch` arm (predict) of nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit_wmatch__a549_mantis_h2b_denv + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_wmatch/checkpoints/epoch=23-step=12000-loss=0.708.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/ipsc/a549__denv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..8c3921ec7 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch` arm (predict) of nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock + model_name: pix2pix2d_unetvit_wmatch + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit_wmatch__a549_mantis_h2b_mock + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_wmatch/checkpoints/epoch=23-step=12000-loss=0.708.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/ipsc/a549__mock/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..83f25e3a2 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch` arm (predict) of nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit_wmatch__a549_mantis_h2b_zikv + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_wmatch/checkpoints/epoch=23-step=12000-loss=0.708.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..1a9882ece --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit_wmatch__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_wmatch/checkpoints/epoch=23-step=12000-loss=0.708.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/ipsc/ipsc/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_NUCL_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/train.yml new file mode 100644 index 000000000..ff73a282d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/ipsc_confocal/train.yml @@ -0,0 +1,69 @@ +# pix2pix2d `wmatch` arm (fit) of nucleus/pix2pix2d_unetvit/ipsc_confocal/train.yml. +# Recipe delta: warmup_steps 8500 -> 1328. Run-D's 8500-batch warmup is +# 13.3 % of the matching 3D fit (64000 batches); this 2D fit runs 10000, so +# round(8500 * 10000 / 64000) keeps the same schedule shape. The baseline's absolute 8500 +# left 5 of 12 2D fits still warming up at their last step (wandb lr-AdamW, 2026-10-22). +# Everything else, and the rationale for it, is the baseline leaf's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_fit_leaves.py. +base: +- ../../../_internal/shared/model/train_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + gene: Nuclei + target: nucleus + target_id: nucleus + train_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit_wmatch + dataset_ref: null +data: + init_args: + source_channel: Phase3D + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Nuclei + w_key: Nuclei + spatial_size: + - 1 + - 624 + - 624 + num_samples: 2 +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_wmatch_iPSC_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_wmatch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: epoch={epoch}-step={step}-loss={loss/validate_ema:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_wmatch/checkpoints +launcher: + job_name: pix2pix2d_unetvit_wmatch_iPSC_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_wmatch + sbatch: + constraint: a40|a6000|l40s|h100|h200 + mem: 128G +model: + init_args: + warmup_steps: 1328 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..bff7d739f --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch` arm (predict) of nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_denv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_h2b_denv + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix2d_unetvit_wmatch/checkpoints/epoch=36-step=29600-loss=1.259.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/joint/a549__denv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_JOINT_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..6485dce12 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch` arm (predict) of nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_mock + model_name: pix2pix2d_unetvit_wmatch + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_h2b_mock + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix2d_unetvit_wmatch/checkpoints/epoch=36-step=29600-loss=1.259.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/joint/a549__mock/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_JOINT_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..e52906cf0 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch` arm (predict) of nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: a549_mantis_h2b_zikv + model_name: pix2pix2d_unetvit_wmatch + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch__a549_mantis_h2b_zikv + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix2d_unetvit_wmatch/checkpoints/epoch=36-step=29600-loss=1.259.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/joint/a549__zikv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_JOINT_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml new file mode 100644 index 000000000..9a962646d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch` arm (predict) of nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: joint_ipsc_confocal_a549_mantis + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix2d_unetvit_wmatch/checkpoints/epoch=36-step=29600-loss=1.259.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/joint/ipsc/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_PRED_JOINT_NUCL_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/train.yml new file mode 100644 index 000000000..68db28537 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch/joint_ipsc_confocal_a549_mantis/train.yml @@ -0,0 +1,207 @@ +# pix2pix2d `wmatch` arm (fit) of nucleus/pix2pix2d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml. +# Recipe delta: warmup_steps 8500 -> 1269. Run-D's 8500-batch warmup is +# 7.9 % of the matching 3D fit (107200 batches); this 2D fit runs 16000, so +# round(8500 * 16000 / 107200) keeps the same schedule shape. The baseline's absolute 8500 +# left 5 of 12 2D fits still warming up at their last step (wandb lr-AdamW, 2026-10-22). +# Everything else, and the rationale for it, is the baseline leaf's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_fit_leaves.py. +base: +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + gene: Nuclei + target: nucleus + target_id: nucleus + train_set: joint_ipsc_confocal_a549_mantis + model_name: pix2pix2d_unetvit_wmatch + experiment_id: nucleus__joint_ipsc_confocal_a549_mantis__pix2pix2d_unetvit_wmatch +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_wmatch_JOINT_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix2d_unetvit_wmatch + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: epoch={epoch}-step={step}-loss={loss/validate_ema:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix2d_unetvit_wmatch/checkpoints +_hcs_init_args: + source_channel: Phase3D + target_channel: Nuclei + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: &id001 + - 512 + - 512 + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: &id002 + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Nuclei + level: fov_statistics + subtrahend: median + divisor: iqr + augmentations: &id003 + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Nuclei + w_key: Nuclei + spatial_size: + - 1 + - 624 + - 624 + num_samples: 2 + gpu_augmentations: &id004 + - class_path: viscy_transforms.BatchedRandAffined + init_args: + keys: + - source + - target + prob: 0.8 + rotate_range: + - 0 + - 0 + - 0 + shear_range: + - 0.0 + - 0.05 + - 0.05 + scale_range: + - - 1 + - 1 + - - 0.5 + - 1.5 + - - 0.5 + - 1.5 + safe_crop_size: + - 1 + - 512 + - 512 + safe_crop_coverage: 0.9 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: + - source + - target + roi_size: + - 1 + - 512 + - 512 + - class_path: viscy_transforms.BatchedRandAdjustContrastd + init_args: + keys: + - source + prob: 0.5 + gamma: + - 0.8 + - 1.2 + - class_path: viscy_transforms.BatchedRandScaleIntensityd + init_args: + keys: + - source + prob: 0.5 + factors: 0.5 + - class_path: viscy_transforms.BatchedRandGaussianNoised + init_args: + keys: + - source + prob: 0.5 + mean: 0.0 + std: 0.3 + - class_path: viscy_transforms.BatchedRandGaussianSmoothd + init_args: + keys: + - source + prob: 0.5 + sigma_x: + - 0.25 + - 0.75 + sigma_y: + - 0.25 + - 0.75 + sigma_z: + - 0 + - 0 + val_gpu_augmentations: &id005 + - class_path: viscy_transforms.BatchedCenterSpatialCropd + init_args: + keys: + - source + - target + roi_size: + - 1 + - 512 + - 512 +data: + class_path: viscy_data.BatchedConcatDataModule + init_args: + data_modules: + - class_path: viscy_data.hcs.HCSDataModule + init_args: + source_channel: Phase3D + target_channel: Nuclei + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: *id001 + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: *id002 + augmentations: *id003 + gpu_augmentations: *id004 + val_gpu_augmentations: *id005 + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + - class_path: viscy_data.hcs.HCSDataModule + init_args: + source_channel: Phase3D + target_channel: Nuclei + z_window_size: 1 + batch_size: 2 + num_workers: 4 + yx_patch_size: *id001 + split_ratio: 0.8 + mmap_preload: true + scratch_dir: /dev/shm + persistent_workers: true + normalizations: *id002 + augmentations: *id003 + gpu_augmentations: *id004 + val_gpu_augmentations: *id005 + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all_focus.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_JOINT_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix2d_unetvit_wmatch + sbatch: + constraint: a40|a6000|l40s|h100|h200 + mem: 128G +model: + init_args: + warmup_steps: 1269 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_denv.yml new file mode 100644 index 000000000..18c0399bd --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_denv.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch_seed1` arm (predict) of nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv + model_name: pix2pix2d_unetvit_wmatch_seed1 + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit_wmatch_seed1__a549_mantis_h2b_denv + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_wmatch_seed1/checkpoints/epoch=25-step=13000-loss=0.710.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__denv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__denv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_seed1_PRED_NUCL_ON_A549_DENV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_mock.yml new file mode 100644 index 000000000..6ce8eab4d --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_mock.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch_seed1` arm (predict) of nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock + model_name: pix2pix2d_unetvit_wmatch_seed1 + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit_wmatch_seed1__a549_mantis_h2b_mock + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_wmatch_seed1/checkpoints/epoch=25-step=13000-loss=0.710.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__mock__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__mock/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_seed1_PRED_NUCL_ON_A549_MOCK + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml new file mode 100644 index 000000000..562b819e1 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -0,0 +1,44 @@ +# pix2pix2d `wmatch_seed1` arm (predict) of nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv + model_name: pix2pix2d_unetvit_wmatch_seed1 + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit_wmatch_seed1__a549_mantis_h2b_zikv + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_wmatch_seed1/checkpoints/epoch=25-step=13000-loss=0.710.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/a549__zikv__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_seed1_PRED_NUCL_ON_A549_ZIKV + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__ipsc_confocal.yml new file mode 100644 index 000000000..c5bea1090 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/predict__ipsc_confocal.yml @@ -0,0 +1,42 @@ +# pix2pix2d `wmatch_seed1` arm (predict) of nucleus/pix2pix2d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml. +# Checkpoint: the arm's best loss/validate_ema epoch, from a fit whose log reads +# `Trainer.fit stopped: max_epochs=40 reached`. Output store, run root and job name +# gain the arm name; the slab3 predict_z_planes and everything else are the baseline's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_predict_and_buckets.py. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch_seed1 + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit_wmatch_seed1__ipsc_confocal +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_wmatch_seed1/checkpoints/epoch=25-step=13000-loss=0.710.ckpt +data: + init_args: + predict_z_planes: /hpc/projects/virtual_staining/training/dynacell/focus2d_planes/nucleus/ipsc__h1.json + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/ipsc/prediction.zarr +launcher: + job_name: pix2pix2d_unetvit_wmatch_seed1_PRED_NUCL_ON_IPSC + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/train.yml new file mode 100644 index 000000000..f40248429 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix2d_unetvit_wmatch_seed1/ipsc_confocal/train.yml @@ -0,0 +1,71 @@ +# pix2pix2d `wmatch_seed1` arm (fit) of nucleus/pix2pix2d_unetvit/ipsc_confocal/train.yml. +# Recipe delta: warmup_steps 8500 -> 1328. Run-D's 8500-batch warmup is +# 13.3 % of the matching 3D fit (64000 batches); this 2D fit runs 10000, so +# round(8500 * 10000 / 64000) keeps the same schedule shape. The baseline's absolute 8500 +# left 5 of 12 2D fits still warming up at their last step (wandb lr-AdamW, 2026-10-22). +# Plus seed_everything: 1 (second draw of the arm). +# Everything else, and the rationale for it, is the baseline leaf's. +# Written by applications/dynacell/experiments/2026-10-22_2d-benchmark-paper-appendix/make_wmatch_fit_leaves.py. +base: +- ../../../_internal/shared/model/train_sets/ipsc_confocal.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/data_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/model_overlays/pix2pix2d_unetvit_fit.yml +- ../../../_internal/shared/model/launcher_profiles/mode_fit.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_4gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + gene: Nuclei + target: nucleus + target_id: nucleus + train_set: ipsc_confocal + model_name: pix2pix2d_unetvit_wmatch_seed1 + experiment_id: nucleus__ipsc_confocal__pix2pix2d_unetvit_wmatch_seed1 + dataset_ref: null +data: + init_args: + source_channel: Phase3D + target_channel: Nuclei + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell_focus.zarr + augmentations: + - class_path: viscy_transforms.RandWeightedCropd + init_args: + keys: + - Phase3D + - Nuclei + w_key: Nuclei + spatial_size: + - 1 + - 624 + - 624 + num_samples: 2 +trainer: + logger: + init_args: + name: pix2pix2d_unetvit_wmatch_seed1_iPSC_NUCL + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_wmatch_seed1 + callbacks: + - class_path: lightning.pytorch.callbacks.LearningRateMonitor + init_args: + logging_interval: step + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + monitor: loss/validate_ema + filename: epoch={epoch}-step={step}-loss={loss/validate_ema:.3f} + auto_insert_metric_name: false + every_n_epochs: 1 + save_top_k: 4 + save_last: true + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_wmatch_seed1/checkpoints +launcher: + job_name: pix2pix2d_unetvit_wmatch_seed1_iPSC_NUCL + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix2d_unetvit_wmatch_seed1 + sbatch: + constraint: a40|a6000|l40s|h100|h200 + mem: 128G +model: + init_args: + warmup_steps: 1328 +seed_everything: 1 diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_denv.yml index 875a6f8b4..5e917a027 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_denv.yml @@ -24,7 +24,7 @@ model: # Best loss/validate_ema checkpoint, modernized Run-D 40ep run (job # 33501550, best at epoch 39, validate_ema=1.51563). predict_step uses # generator_ema (use_ema_at_predict=True default). - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=39-step=86400.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix3d_unetvit/checkpoints/epoch=39-step=86400.ckpt data: init_args: @@ -43,8 +43,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit_a549trained__h2b_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__denv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_A549TR_PRED_NUCL_h2b_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_mock.yml index 537deb4b0..17bc8edb7 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_mock.yml @@ -24,7 +24,7 @@ model: # Best loss/validate_ema checkpoint, modernized Run-D 40ep run (job # 33501550, best at epoch 39, validate_ema=1.51563). predict_step uses # generator_ema (use_ema_at_predict=True default). - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=39-step=86400.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix3d_unetvit/checkpoints/epoch=39-step=86400.ckpt data: init_args: @@ -43,8 +43,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit_a549trained__h2b_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__mock/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_A549TR_PRED_NUCL_h2b_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml index 7a3de3fab..b1dcc9362 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/predict__a549_mantis_zikv.yml @@ -24,7 +24,7 @@ model: # Best loss/validate_ema checkpoint, modernized Run-D 40ep run (job # 33501550, best at epoch 39, validate_ema=1.51563). predict_step uses # generator_ema (use_ema_at_predict=True default). - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=39-step=86400.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix3d_unetvit/checkpoints/epoch=39-step=86400.ckpt data: init_args: @@ -43,8 +43,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit_a549trained__h2b_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__zikv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_A549TR_PRED_NUCL_h2b_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/predict__ipsc_confocal.yml index 37c8cd796..492583676 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/predict__ipsc_confocal.yml @@ -20,7 +20,7 @@ model: # Best loss/validate_ema checkpoint, modernized Run-D 40ep run (job # 33501550, best at epoch 39, validate_ema=1.51563). predict_step uses # generator_ema (use_ema_at_predict=True default). - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=39-step=86400.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix3d_unetvit/checkpoints/epoch=39-step=86400.ckpt data: init_args: @@ -39,8 +39,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_pix2pix3d_unetvit_a549trained.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/ipsc/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_A549TR_PRED_NUCL_ON_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/a549/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/train.yml index 63aa2b781..414562e39 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/train.yml @@ -27,6 +27,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml index b8f0b5efb..2136ca1dd 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/a549_mantis/train_4gpu_modernized.yml @@ -31,7 +31,7 @@ trainer: logger: init_args: name: pix2pix3d_unetvit_A549_NUCL_4gpu_modernized_lambdaL1_10_lecam_40ep - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix3d_unetvit callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -39,10 +39,12 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix3d_unetvit/checkpoints data: init_args: @@ -52,7 +54,7 @@ data: launcher: job_name: pix2pix3d_unetvit_A549_NUCL_4gpu_modernized_lambdaL1_10_lecam_40ep - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/a549_mantis/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/a549/nucleus/pix2pix3d_unetvit # pix2pix3d GAN (UNetViT3D G + multiscale-patch D, large 3D crops) OOMs on # 80 GB h100; needs h200 (141 GB). Narrow the hardware_4gpu h100|h200 default. sbatch: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index 03bdb1fce..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: nucleus (Nuclei) predicted by pix2pix3d_unetvit on a549-mantis-h2b-denv. -defaults: - - override /target: nucleus - - override /predict_set: a549_mantis_h2b_denv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit__h2b_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_nucl_pix2pix3d_unetvit__h2b_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index 0ea3c544b..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: nucleus (Nuclei) predicted by pix2pix3d_unetvit on a549-mantis-h2b-mock. -defaults: - - override /target: nucleus - - override /predict_set: a549_mantis_h2b_mock - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit__h2b_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_nucl_pix2pix3d_unetvit__h2b_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index bbe85c533..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: nucleus (Nuclei) predicted by pix2pix3d_unetvit on a549-mantis-h2b-zikv. -defaults: - - override /target: nucleus - - override /predict_set: a549_mantis_h2b_zikv - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit__h2b_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_nucl_pix2pix3d_unetvit__h2b_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 100644 index 9f548eeb9..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: nucleus (Nuclei) predicted by pix2pix3d_unetvit on iPSC confocal. -defaults: - - override /target: nucleus - - override /predict_set: ipsc_confocal - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_pix2pix3d_unetvit.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/eval_nucl_pix2pix3d_unetvit diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml index 658fb1fdd..b9028d984 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_denv.yml @@ -22,9 +22,11 @@ benchmark: model: init_args: # Best loss/validate_ema checkpoint, modernized Run-D 40ep run (job - # 33501549, converged early at epoch 15). predict_step uses generator_ema - # (use_ema_at_predict=True default). - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=15-step=51200.ckpt + # 33501549, converged early at epoch 15). The checkpoint was SELECTED on the + # EMA loss, and predict_step uses generator_ema: see the ema_kimg / + # use_ema_at_predict block in model_overlays/pix2pix3d_unetvit_predict.yml, + # which pins use_ema_at_predict: true. + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix3d_unetvit/checkpoints/epoch=15-step=51200.ckpt data: init_args: @@ -43,8 +45,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit__h2b_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__denv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_PRED_NUCL_ON_A549_h2b_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml index 117049900..b4281741f 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_mock.yml @@ -22,9 +22,11 @@ benchmark: model: init_args: # Best loss/validate_ema checkpoint, modernized Run-D 40ep run (job - # 33501549, converged early at epoch 15). predict_step uses generator_ema - # (use_ema_at_predict=True default). - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=15-step=51200.ckpt + # 33501549, converged early at epoch 15). The checkpoint was SELECTED on the + # EMA loss, and predict_step uses generator_ema: see the ema_kimg / + # use_ema_at_predict block in model_overlays/pix2pix3d_unetvit_predict.yml, + # which pins use_ema_at_predict: true. + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix3d_unetvit/checkpoints/epoch=15-step=51200.ckpt data: init_args: @@ -43,8 +45,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit__h2b_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__mock/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_PRED_NUCL_ON_A549_h2b_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml index bcbc086f6..08c03031f 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -22,9 +22,11 @@ benchmark: model: init_args: # Best loss/validate_ema checkpoint, modernized Run-D 40ep run (job - # 33501549, converged early at epoch 15). predict_step uses generator_ema - # (use_ema_at_predict=True default). - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=15-step=51200.ckpt + # 33501549, converged early at epoch 15). The checkpoint was SELECTED on the + # EMA loss, and predict_step uses generator_ema: see the ema_kimg / + # use_ema_at_predict block in model_overlays/pix2pix3d_unetvit_predict.yml, + # which pins use_ema_at_predict: true. + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix3d_unetvit/checkpoints/epoch=15-step=51200.ckpt data: init_args: @@ -43,8 +45,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucl_pix2pix3d_unetvit__h2b_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__zikv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_PRED_NUCL_ON_A549_h2b_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml index 2ab5097a0..4e4d35f6c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/predict__ipsc_confocal.yml @@ -18,9 +18,11 @@ benchmark: model: init_args: # Best loss/validate_ema checkpoint, modernized Run-D 40ep run (job - # 33501549, converged early at epoch 15). predict_step uses generator_ema - # (use_ema_at_predict=True default). - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=15-step=51200.ckpt + # 33501549, converged early at epoch 15). The checkpoint was SELECTED on the + # EMA loss, and predict_step uses generator_ema: see the ema_kimg / + # use_ema_at_predict block in model_overlays/pix2pix3d_unetvit_predict.yml, + # which pins use_ema_at_predict: true. + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix3d_unetvit/checkpoints/epoch=15-step=51200.ckpt data: init_args: @@ -39,8 +41,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucl_pix2pix3d_unetvit.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/ipsc/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_PRED_NUCL - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/train.yml index 7ccba9fcd..37ed1e4d7 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/train.yml @@ -27,6 +27,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml index b75fdb66e..0d04c9c04 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/ipsc_confocal/train_4gpu_modernized.yml @@ -31,7 +31,7 @@ trainer: logger: init_args: name: pix2pix3d_unetvit_iPSC_NUCL_4gpu_modernized_lambdaL1_10_lecam_40ep - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix3d_unetvit callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -39,14 +39,16 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix3d_unetvit/checkpoints launcher: job_name: pix2pix3d_unetvit_iPSC_NUCL_4gpu_modernized_lambdaL1_10_lecam_40ep - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/pix2pix3d_unetvit # pix2pix3d GAN (UNetViT3D G + multiscale-patch D, large 3D crops) OOMs on # 80 GB h100; needs h200 (141 GB). Narrow the hardware_4gpu h100|h200 default. sbatch: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml index b9b239aba..4cf819162 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_denv.yml @@ -24,7 +24,7 @@ model: # Best loss/validate_ema checkpoint, modernized Run-D 40ep run (job # 33502019, best at epoch 39, validate_ema=1.00041). predict_step uses # generator_ema (use_ema_at_predict=True default). - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=39-step=214400.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix3d_unetvit/checkpoints/epoch=39-step=214400.ckpt data: init_args: @@ -43,8 +43,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_pix2pix3d_unetvit__h2b_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__denv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_JOINT_PRED_NUCL_ON_A549_h2b_denv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml index 0f8d30df0..6bc2bab02 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_mock.yml @@ -24,7 +24,7 @@ model: # Best loss/validate_ema checkpoint, modernized Run-D 40ep run (job # 33502019, best at epoch 39, validate_ema=1.00041). predict_step uses # generator_ema (use_ema_at_predict=True default). - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=39-step=214400.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix3d_unetvit/checkpoints/epoch=39-step=214400.ckpt data: init_args: @@ -43,8 +43,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_pix2pix3d_unetvit__h2b_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__mock/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_JOINT_PRED_NUCL_ON_A549_h2b_mock - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml index 8eb87a9b5..4075876b5 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__a549_mantis_zikv.yml @@ -24,7 +24,7 @@ model: # Best loss/validate_ema checkpoint, modernized Run-D 40ep run (job # 33502019, best at epoch 39, validate_ema=1.00041). predict_step uses # generator_ema (use_ema_at_predict=True default). - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=39-step=214400.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix3d_unetvit/checkpoints/epoch=39-step=214400.ckpt data: init_args: @@ -43,8 +43,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions/nucl_pix2pix3d_unetvit__h2b_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__zikv/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_JOINT_PRED_NUCL_ON_A549_h2b_zikv - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml index ccd6b8733..9dd6a7615 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/predict__ipsc_confocal.yml @@ -20,7 +20,7 @@ model: # Best loss/validate_ema checkpoint, modernized Run-D 40ep run (job # 33502019, best at epoch 39, validate_ema=1.00041). predict_step uses # generator_ema (use_ema_at_predict=True default). - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints/epoch=39-step=214400.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix3d_unetvit/checkpoints/epoch=39-step=214400.ckpt data: init_args: @@ -39,8 +39,13 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions/nucl_pix2pix3d_unetvit.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/ipsc/prediction.zarr + # Take each plane from the depth window centred on it instead of the mean + # of all 8 covering windows: that mean halves mid-band power (0.045 -> + # 0.021 of ground truth on an in-domain membrane FOV) and cancels none of + # the XY lattice, since all 8 share one XY grid. + z_reduction: center launcher: job_name: pix2pix3d_unetvit_JOINT_PRED_NUCL_ON_IPSC - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/joint_predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/pix2pix3d_unetvit/joint/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml index f8d5457a6..4b6894378 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train.yml @@ -39,6 +39,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml index 51df42f6c..3aaa0112b 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/pix2pix3d_unetvit/joint_ipsc_confocal_a549_mantis/train_4gpu_modernized.yml @@ -43,7 +43,7 @@ trainer: logger: init_args: name: pix2pix3d_unetvit_JOINT_NUCL_4gpu_modernized_lambdaL1_10_lecam_40ep - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix3d_unetvit callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -51,10 +51,12 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate_ema + filename: "epoch={epoch}-step={step}-loss={loss/validate_ema:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix3d_unetvit/checkpoints # Child HCSDataModule init_args shared across both datasets (only data_path # differs). `_`-prefixed top-level keys are stripped by load_composed_config @@ -152,7 +154,7 @@ data: launcher: job_name: pix2pix3d_unetvit_JOINT_NUCL_4gpu_modernized_lambdaL1_10_lecam_40ep - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/joint_ipsc_confocal_a549_mantis/nucl/pix2pix3d_unetvit_modernized_lambdaL1_10_lecam_40ep + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/joint/nucleus/pix2pix3d_unetvit # pix2pix3d GAN (UNetViT3D G + multiscale-patch D, large 3D crops) OOMs on # 80 GB h100; needs h200 (141 GB). Narrow the hardware_4gpu h100|h200 default. sbatch: diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/a549_mantis/train.yml index 759e49978..4d2a0eb53 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/a549_mantis/train.yml @@ -27,6 +27,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml deleted file mode 100644 index fa77376fd..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_denv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Nucleus (H2B) predicted by UNetViT3D on a549-mantis-h2b-denv. -# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` -# target_id from the target group so the resolver finds h2b on a549-mantis-h2b-denv. -defaults: - - override /target: nucleus - - override /predict_set: a549_mantis_h2b_denv - -benchmark: - dataset_ref: - target: h2b - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucleus_unetvit3d_denv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_nucleus_unetvit3d_denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml deleted file mode 100644 index f16267809..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_mock.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Nucleus (H2B) predicted by UNetViT3D on a549-mantis-h2b-mock. -# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` -# target_id from the target group so the resolver finds h2b on a549-mantis-h2b-mock. -defaults: - - override /target: nucleus - - override /predict_set: a549_mantis_h2b_mock - -benchmark: - dataset_ref: - target: h2b - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucleus_unetvit3d_mock.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_nucleus_unetvit3d_mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml deleted file mode 100644 index c4a555eea..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/eval__a549_mantis_zikv.yaml +++ /dev/null @@ -1,19 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Nucleus (H2B) predicted by UNetViT3D on a549-mantis-h2b-zikv. -# A549 manifest keys nucleus by gene (`h2b`); override the iPSC-side `nucleus` -# target_id from the target group so the resolver finds h2b on a549-mantis-h2b-zikv. -defaults: - - override /target: nucleus - - override /predict_set: a549_mantis_h2b_zikv - -benchmark: - dataset_ref: - target: h2b - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucleus_unetvit3d_zikv.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/eval_nucleus_unetvit3d_zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml deleted file mode 100644 index e22f22915..000000000 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/eval__ipsc_confocal.yaml +++ /dev/null @@ -1,13 +0,0 @@ -# @package _global_ -# Benchmark eval leaf: Nucleus predicted by UNetViT3D on iPSC confocal. -defaults: - - override /target: nucleus - - override /predict_set: ipsc_confocal - -io: - pred_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucleus_unetvit3d.zarr - -compute_feature_metrics: true - -save: - save_dir: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/eval_nucleus_unetvit3d diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml index 052f53080..f6303a30d 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/unetvit3d/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/unetvit3d/checkpoints/epoch=19-step=128000.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucleus_unetvit3d_denv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/a549__denv/prediction.zarr launcher: job_name: UNetViT3D_PRED_NUCLEUS_ON_A549_DENV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_denv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_denv_lite.yml new file mode 100644 index 000000000..5e3282f85 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_denv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_denv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_denv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_denv_lite + model_name: unetvit3d + experiment_id: nucleus__ipsc_confocal__unetvit3d__a549_mantis_h2b_denv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/unetvit3d/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/unetvit3d/ipsc/a549__denv/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_NUCLEUS_ON_A549_DENV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/unetvit3d/ipsc/a549__denv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml index b2f8f8095..9d4c17bb3 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/unetvit3d/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/unetvit3d/checkpoints/epoch=19-step=128000.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucleus_unetvit3d_mock.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/a549__mock/prediction.zarr launcher: job_name: UNetViT3D_PRED_NUCLEUS_ON_A549_MOCK - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_mock_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_mock_lite.yml new file mode 100644 index 000000000..72ccb896c --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_mock_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_mock.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_mock_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_mock_lite + model_name: unetvit3d + experiment_id: nucleus__ipsc_confocal__unetvit3d__a549_mantis_h2b_mock__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/unetvit3d/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/unetvit3d/ipsc/a549__mock/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_NUCLEUS_ON_A549_MOCK_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/unetvit3d/ipsc/a549__mock diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml index 32597b74a..05ec15d2e 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml @@ -23,7 +23,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/unetvit3d/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/unetvit3d/checkpoints/epoch=19-step=128000.ckpt data: init_args: @@ -42,8 +42,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/a549/predictions/nucleus_unetvit3d_zikv.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/a549__zikv/prediction.zarr launcher: job_name: UNetViT3D_PRED_NUCLEUS_ON_A549_ZIKV - run_root: /hpc/projects/virtual_staining/training/dynacell/a549/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv_lite.yml new file mode 100644 index 000000000..6dccc2217 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv_lite.yml @@ -0,0 +1,39 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__a549_mantis_zikv.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/a549_mantis_h2b_zikv_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: a549_mantis_h2b_zikv_lite + model_name: unetvit3d + experiment_id: nucleus__ipsc_confocal__unetvit3d__a549_mantis_h2b_zikv__lite + dataset_ref: + target: h2b +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/unetvit3d/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/unetvit3d/ipsc/a549__zikv/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_NUCLEUS_ON_A549_ZIKV_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/unetvit3d/ipsc/a549__zikv diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml index 5d8b4ca9a..f5dda30b5 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml @@ -17,7 +17,7 @@ benchmark: model: init_args: - ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/unetvit3d/checkpoints/last.ckpt + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/unetvit3d/checkpoints/epoch=19-step=128000.ckpt data: init_args: @@ -36,8 +36,8 @@ trainer: callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: - output_store: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions/nucleus_unetvit3d.zarr + output_store: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/ipsc/prediction.zarr launcher: job_name: UNetViT3D_PRED_NUCLEUS - run_root: /hpc/projects/virtual_staining/training/dynacell/ipsc/predictions + run_root: /hpc/projects/virtual_staining/training/dynacell/nucleus/unetvit3d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__ipsc_confocal_lite.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__ipsc_confocal_lite.yml new file mode 100644 index 000000000..0b932c792 --- /dev/null +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__ipsc_confocal_lite.yml @@ -0,0 +1,37 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/predict__ipsc_confocal.yml. Do not edit; regenerate. +base: +- ../../../_internal/shared/model/predict_sets/ipsc_confocal_lite.yml +- ../../../_internal/shared/model/targets/nucleus.yml +- ../../../_internal/shared/model/model_overlays/unetvit3d_predict.yml +- ../../../_internal/shared/model/launcher_profiles/mode_predict.yml +- ../../../_internal/shared/model/launcher_profiles/hardware_predict_any_gpu.yml +- ../../../_internal/shared/model/launcher_profiles/runtime_shared.yml +benchmark: + task: virtual_staining + organelle: nucleus + trained_on: ipsc_confocal + predict_set: ipsc_confocal_lite + model_name: unetvit3d + experiment_id: nucleus__ipsc_confocal__unetvit3d__ipsc_confocal__lite +model: + init_args: + ckpt_path: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/unetvit3d/checkpoints/epoch=19-step=128000.ckpt +data: + init_args: + normalizations: + - class_path: viscy_transforms.NormalizeSampled + init_args: + keys: + - Phase3D + level: fov_statistics + subtrahend: mean + divisor: std + augmentations: [] +trainer: + callbacks: + - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter + init_args: + output_store: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/unetvit3d/ipsc/ipsc/prediction.zarr +launcher: + job_name: UNetViT3D_PRED_NUCLEUS_LITE + run_root: /hpc/projects/virtual_staining/training/dynacell_lite/nucleus/unetvit3d/ipsc/ipsc diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/train.yml index ef6f7334a..813a4f7d6 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/ipsc_confocal/train.yml @@ -19,7 +19,7 @@ trainer: logger: init_args: name: UNetViT3D_iPSC_NUCL - save_dir: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/unetvit3d + save_dir: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/unetvit3d callbacks: - class_path: lightning.pytorch.callbacks.LearningRateMonitor init_args: @@ -27,11 +27,13 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true - dirpath: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/unetvit3d/checkpoints + dirpath: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/unetvit3d/checkpoints launcher: job_name: UNetViT3D_NUCL - run_root: /hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy/ipsc/nucl/unetvit3d + run_root: /hpc/projects/comp.micro/virtual_staining/models/dynacell/ipsc/nucleus/unetvit3d diff --git a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/joint_ipsc_confocal_a549_mantis/train.yml b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/joint_ipsc_confocal_a549_mantis/train.yml index 875860261..3ecf2573c 100644 --- a/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/joint_ipsc_confocal_a549_mantis/train.yml +++ b/applications/dynacell/configs/benchmarks/virtual_staining/nucleus/unetvit3d/joint_ipsc_confocal_a549_mantis/train.yml @@ -41,6 +41,8 @@ trainer: - class_path: lightning.pytorch.callbacks.ModelCheckpoint init_args: monitor: loss/validate + filename: "epoch={epoch}-step={step}-loss={loss/validate:.3f}" + auto_insert_metric_name: false every_n_epochs: 1 save_top_k: 4 save_last: true diff --git a/applications/dynacell/configs/collections/virtual_staining/membrane_ipsc_v1.yaml b/applications/dynacell/configs/collections/virtual_staining/membrane_ipsc_v1.yaml new file mode 100644 index 000000000..3cb4f067b --- /dev/null +++ b/applications/dynacell/configs/collections/virtual_staining/membrane_ipsc_v1.yaml @@ -0,0 +1,658 @@ +name: membrane_ipsc_v1 +description: Frozen benchmark collection for 'aics-hipsc' target 'membrane'. Channels + and FOV membership captured from the live train/test zarr stores at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-27T12:03:25.118506+00:00' + created_by: Alex Kalinin +experiments: +- name: membrane_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Membrane + organelle: membrane + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: membrane_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Membrane + organelle: membrane + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +train_fovs: +- membrane_hipsc_train/4/10615/1304 +- membrane_hipsc_train/4/10625/1347 +- membrane_hipsc_train/4/10900/1427 +- membrane_hipsc_train/4/10904/1436 +- membrane_hipsc_train/4/11384/1404 +- membrane_hipsc_train/4/11478/1468 +- membrane_hipsc_train/4/11490/1466 +- membrane_hipsc_train/4/11492/1467 +- membrane_hipsc_train/4/11573/1414 +- membrane_hipsc_train/4/136707/16750 +- membrane_hipsc_train/4/136710/15363 +- membrane_hipsc_train/4/136721/16107 +- membrane_hipsc_train/4/136725/15834 +- membrane_hipsc_train/4/13974/1528 +- membrane_hipsc_train/4/14646/1871 +- membrane_hipsc_train/4/14740/1745 +- membrane_hipsc_train/4/14742/1791 +- membrane_hipsc_train/4/14754/1781 +- membrane_hipsc_train/4/1493/268 +- membrane_hipsc_train/4/1508/255 +- membrane_hipsc_train/4/16278/2186 +- membrane_hipsc_train/4/16376/2374 +- membrane_hipsc_train/4/16468/2321 +- membrane_hipsc_train/4/16469/2337 +- membrane_hipsc_train/4/16469/2339 +- membrane_hipsc_train/4/16469/2345 +- membrane_hipsc_train/4/16471/2265 +- membrane_hipsc_train/4/16472/2312 +- membrane_hipsc_train/4/16951/2459 +- membrane_hipsc_train/4/16951/2480 +- membrane_hipsc_train/4/16952/2494 +- membrane_hipsc_train/4/17333/2710 +- membrane_hipsc_train/4/17348/16148 +- membrane_hipsc_train/4/17525/2811 +- membrane_hipsc_train/4/17526/2752 +- membrane_hipsc_train/4/17536/2773 +- membrane_hipsc_train/4/18020/1618 +- membrane_hipsc_train/4/18020/1625 +- membrane_hipsc_train/4/18020/1638 +- membrane_hipsc_train/4/18487/1811 +- membrane_hipsc_train/4/19351/1905 +- membrane_hipsc_train/4/19543/2105 +- membrane_hipsc_train/4/19554/2020 +- membrane_hipsc_train/4/19556/2089 +- membrane_hipsc_train/4/20416/2223 +- membrane_hipsc_train/4/20596/2406 +- membrane_hipsc_train/4/20597/2395 +- membrane_hipsc_train/4/20597/2401 +- membrane_hipsc_train/4/20599/2373 +- membrane_hipsc_train/4/21077/2254 +- membrane_hipsc_train/4/21089/2293 +- membrane_hipsc_train/4/21556/2491 +- membrane_hipsc_train/4/21557/2483 +- membrane_hipsc_train/4/21557/2527 +- membrane_hipsc_train/4/21653/2547 +- membrane_hipsc_train/4/21860/15671 +- membrane_hipsc_train/4/21940/2736 +- membrane_hipsc_train/4/21943/2717 +- membrane_hipsc_train/4/21953/2739 +- membrane_hipsc_train/4/22133/2826 +- membrane_hipsc_train/4/22136/2827 +- membrane_hipsc_train/4/22339/3095 +- membrane_hipsc_train/4/22340/3097 +- membrane_hipsc_train/4/22612/2915 +- membrane_hipsc_train/4/22614/2923 +- membrane_hipsc_train/4/22615/2978 +- membrane_hipsc_train/4/22624/2909 +- membrane_hipsc_train/4/22709/3070 +- membrane_hipsc_train/4/22712/3090 +- membrane_hipsc_train/4/22913/3301 +- membrane_hipsc_train/4/22914/3289 +- membrane_hipsc_train/4/23380/3237 +- membrane_hipsc_train/4/23392/3212 +- membrane_hipsc_train/4/23395/3223 +- membrane_hipsc_train/4/23574/3492 +- membrane_hipsc_train/4/23764/3409 +- membrane_hipsc_train/4/24152/3567 +- membrane_hipsc_train/4/24724/3661 +- membrane_hipsc_train/4/24727/3659 +- membrane_hipsc_train/4/24928/3585 +- membrane_hipsc_train/4/25784/3851 +- membrane_hipsc_train/4/27800/2883 +- membrane_hipsc_train/4/27896/2943 +- membrane_hipsc_train/4/27992/3020 +- membrane_hipsc_train/4/28084/3214 +- membrane_hipsc_train/4/28084/3270 +- membrane_hipsc_train/4/28087/3266 +- membrane_hipsc_train/4/28756/3381 +- membrane_hipsc_train/4/28759/3393 +- membrane_hipsc_train/4/29045/3764 +- membrane_hipsc_train/4/29060/3753 +- membrane_hipsc_train/4/29143/3667 +- membrane_hipsc_train/4/29155/3710 +- membrane_hipsc_train/4/2932/230 +- membrane_hipsc_train/4/29333/3908 +- membrane_hipsc_train/4/2945/173 +- membrane_hipsc_train/4/30292/14379 +- membrane_hipsc_train/4/30293/3905 +- membrane_hipsc_train/4/30308/3869 +- membrane_hipsc_train/4/30388/16862 +- membrane_hipsc_train/4/30389/15342 +- membrane_hipsc_train/4/30392/16741 +- membrane_hipsc_train/4/31732/17059 +- membrane_hipsc_train/4/31744/16779 +- membrane_hipsc_train/4/31841/3962 +- membrane_hipsc_train/4/31939/3975 +- membrane_hipsc_train/4/32024/4077 +- membrane_hipsc_train/4/32033/4111 +- membrane_hipsc_train/4/32033/4121 +- membrane_hipsc_train/4/32035/4099 +- membrane_hipsc_train/4/33077/4379 +- membrane_hipsc_train/4/33572/4229 +- membrane_hipsc_train/4/33942/15337 +- membrane_hipsc_train/4/33942/16205 +- membrane_hipsc_train/4/33943/17061 +- membrane_hipsc_train/4/33953/16561 +- membrane_hipsc_train/4/33955/16023 +- membrane_hipsc_train/4/34038/4363 +- membrane_hipsc_train/4/34808/4417 +- membrane_hipsc_train/4/35000/4274 +- membrane_hipsc_train/4/35284/4472 +- membrane_hipsc_train/4/35287/4460 +- membrane_hipsc_train/4/35479/4551 +- membrane_hipsc_train/4/35489/4583 +- membrane_hipsc_train/4/36449/15327 +- membrane_hipsc_train/4/36544/4909 +- membrane_hipsc_train/4/36544/4931 +- membrane_hipsc_train/4/36628/4907 +- membrane_hipsc_train/4/36836/4996 +- membrane_hipsc_train/4/37591/5133 +- membrane_hipsc_train/4/37603/5147 +- membrane_hipsc_train/4/37972/5388 +- membrane_hipsc_train/4/37988/5373 +- membrane_hipsc_train/4/40084/5359 +- membrane_hipsc_train/4/40086/5362 +- membrane_hipsc_train/4/40376/4584 +- membrane_hipsc_train/4/40385/4614 +- membrane_hipsc_train/4/40386/4613 +- membrane_hipsc_train/4/40387/4586 +- membrane_hipsc_train/4/40483/4619 +- membrane_hipsc_train/4/40483/4621 +- membrane_hipsc_train/4/40960/4654 +- membrane_hipsc_train/4/41044/4851 +- membrane_hipsc_train/4/41047/4885 +- membrane_hipsc_train/4/41237/4861 +- membrane_hipsc_train/4/41249/4835 +- membrane_hipsc_train/4/41912/5074 +- membrane_hipsc_train/4/5143/954 +- membrane_hipsc_train/4/5236/869 +- membrane_hipsc_train/4/5238/875 +- membrane_hipsc_train/4/6485/1018 +- membrane_hipsc_train/4/6486/992 +- membrane_hipsc_train/4/6497/1003 +- membrane_hipsc_train/4/6775/1203 +- membrane_hipsc_train/4/6775/1226 +- membrane_hipsc_train/4/6775/1236 +- membrane_hipsc_train/4/7156/1124 +- membrane_hipsc_train/4/7349/1355 +- membrane_hipsc_train/4/7650/1278 +- membrane_hipsc_train/4/8214/878 +- membrane_hipsc_train/4/8214/879 +- membrane_hipsc_train/4/8228/898 +- membrane_hipsc_train/4/8695/1215 +- membrane_hipsc_train/4/88267/15294 +- membrane_hipsc_train/4/89048/356 +- membrane_hipsc_train/4/8982/1171 +- membrane_hipsc_train/4/90088/415 +- membrane_hipsc_train/4/90858/15658 +- membrane_hipsc_train/4/90858/16534 +- membrane_hipsc_train/4/91144/102 +- membrane_hipsc_train/4/91924/458 +- membrane_hipsc_train/4/93448/596 +- membrane_hipsc_train/4/94312/684 +- membrane_hipsc_train/4/95752/811 +- membrane_hipsc_train/4/95753/737 +- membrane_hipsc_train/4/95753/872 +- membrane_hipsc_train/41/43638/5246 +- membrane_hipsc_train/41/43639/5265 +- membrane_hipsc_train/41/43732/16519 +- membrane_hipsc_train/41/45556/5706 +- membrane_hipsc_train/41/45556/5734 +- membrane_hipsc_train/41/45559/5714 +- membrane_hipsc_train/41/48436/5507 +- membrane_hipsc_train/41/48534/5575 +- membrane_hipsc_train/41/48535/5623 +- membrane_hipsc_train/41/48548/5574 +- membrane_hipsc_train/41/48548/5589 +- membrane_hipsc_train/41/49204/5661 +- membrane_hipsc_train/41/49220/5671 +- membrane_hipsc_train/41/49698/5819 +- membrane_hipsc_train/41/49972/5933 +- membrane_hipsc_train/41/49973/5960 +- membrane_hipsc_train/41/50263/6077 +- membrane_hipsc_train/41/50263/6082 +- membrane_hipsc_train/41/50356/15510 +- membrane_hipsc_train/41/50356/15578 +- membrane_hipsc_train/41/50359/15457 +- membrane_hipsc_train/41/50548/6024 +- membrane_hipsc_train/41/50551/6022 +- membrane_hipsc_train/41/53044/15243 +- membrane_hipsc_train/41/53046/16965 +- membrane_hipsc_train/41/53428/6238 +- membrane_hipsc_train/41/53524/15636 +- membrane_hipsc_train/41/53538/15395 +- membrane_hipsc_train/41/53731/15920 +- membrane_hipsc_train/41/55156/6355 +- membrane_hipsc_train/41/55156/6358 +- membrane_hipsc_train/41/55158/6324 +- membrane_hipsc_train/41/55158/6353 +- membrane_hipsc_train/41/55253/6499 +- membrane_hipsc_train/41/55256/6482 +- membrane_hipsc_train/41/55351/6419 +- membrane_hipsc_train/41/55363/6362 +- membrane_hipsc_train/41/55925/6584 +- membrane_hipsc_train/41/56406/6643 +- membrane_hipsc_train/41/56416/6614 +- membrane_hipsc_train/41/56418/6626 +- membrane_hipsc_train/41/56419/6630 +- membrane_hipsc_train/41/56596/6678 +- membrane_hipsc_train/41/56896/7720 +- membrane_hipsc_train/41/57364/6456 +- membrane_hipsc_train/41/57365/6428 +- membrane_hipsc_train/41/57367/6430 +- membrane_hipsc_train/41/57464/6544 +- membrane_hipsc_train/41/57472/6556 +- membrane_hipsc_train/41/57472/6565 +- membrane_hipsc_train/41/58134/6821 +- membrane_hipsc_train/41/58326/6840 +- membrane_hipsc_train/41/58420/6971 +- membrane_hipsc_train/41/58423/6963 +- membrane_hipsc_train/41/58518/6786 +- membrane_hipsc_train/41/59285/7118 +- membrane_hipsc_train/41/59285/7124 +- membrane_hipsc_train/41/59298/7175 +- membrane_hipsc_train/41/59380/7015 +- membrane_hipsc_train/41/59479/7188 +- membrane_hipsc_train/41/59479/7200 +- membrane_hipsc_train/41/59480/7179 +- membrane_hipsc_train/41/60548/7475 +- membrane_hipsc_train/41/60632/7345 +- membrane_hipsc_train/41/60726/7399 +- membrane_hipsc_train/41/60737/7332 +- membrane_hipsc_train/41/60738/7414 +- membrane_hipsc_train/41/62740/7068 +- membrane_hipsc_train/41/62932/6916 +- membrane_hipsc_train/41/63508/7389 +- membrane_hipsc_train/41/63523/7383 +- membrane_hipsc_train/41/63608/7462 +- membrane_hipsc_train/41/63608/7464 +- membrane_hipsc_train/41/63620/7451 +- membrane_hipsc_train/41/63701/7283 +- membrane_hipsc_train/41/63713/7256 +- membrane_hipsc_train/41/66292/7775 +- membrane_hipsc_train/41/66292/7782 +- membrane_hipsc_train/41/66292/7796 +- membrane_hipsc_train/41/66296/7788 +- membrane_hipsc_train/41/67157/7690 +- membrane_hipsc_train/41/67168/7678 +- membrane_hipsc_train/41/68131/7834 +- membrane_hipsc_train/41/68503/9206 +- membrane_hipsc_train/41/68504/9176 +- membrane_hipsc_train/41/68504/9197 +- membrane_hipsc_train/41/68512/9188 +- membrane_hipsc_train/41/68512/9207 +- membrane_hipsc_train/41/68512/9212 +- membrane_hipsc_train/41/68708/9065 +- membrane_hipsc_train/41/68788/9030 +- membrane_hipsc_train/41/68800/9019 +- membrane_hipsc_train/41/69472/9285 +- membrane_hipsc_train/41/69473/9279 +- membrane_hipsc_train/41/69474/9306 +- membrane_hipsc_train/41/70052/15689 +- membrane_hipsc_train/41/70231/9525 +- membrane_hipsc_train/41/70232/9551 +- membrane_hipsc_train/41/72244/8037 +- membrane_hipsc_train/41/72244/8074 +- membrane_hipsc_train/41/72256/8049 +- membrane_hipsc_train/41/72260/8085 +- membrane_hipsc_train/41/72342/7994 +- membrane_hipsc_train/41/72356/7962 +- membrane_hipsc_train/41/72628/8109 +- membrane_hipsc_train/41/72629/8086 +- membrane_hipsc_train/41/72630/8119 +- membrane_hipsc_train/41/72631/8095 +- membrane_hipsc_train/41/72725/8151 +- membrane_hipsc_train/41/72726/8128 +- membrane_hipsc_train/41/72834/8288 +- membrane_hipsc_train/41/73300/8255 +- membrane_hipsc_train/41/73396/8265 +- membrane_hipsc_train/41/73397/8271 +- membrane_hipsc_train/41/73398/8307 +- membrane_hipsc_train/41/73495/8186 +- membrane_hipsc_train/41/73507/8203 +- membrane_hipsc_train/41/73685/8634 +- membrane_hipsc_train/41/73687/8628 +- membrane_hipsc_train/41/73700/8663 +- membrane_hipsc_train/41/73782/8525 +- membrane_hipsc_train/41/73782/8576 +- membrane_hipsc_train/41/73783/8530 +- membrane_hipsc_train/41/73784/8543 +- membrane_hipsc_train/41/73879/15995 +- membrane_hipsc_train/41/73975/15832 +- membrane_hipsc_train/41/74165/8821 +- membrane_hipsc_train/41/74168/8793 +- membrane_hipsc_train/41/74260/8727 +- membrane_hipsc_train/41/74273/8721 +- membrane_hipsc_train/41/74371/8941 +- membrane_hipsc_train/41/74371/8978 +- membrane_hipsc_train/41/75042/7915 +- membrane_hipsc_train/41/75124/16978 +- membrane_hipsc_train/41/75125/16693 +- membrane_hipsc_train/41/75512/7872 +- membrane_hipsc_train/41/75796/7941 +- membrane_hipsc_train/41/75799/7953 +- membrane_hipsc_train/41/76000/8244 +- membrane_hipsc_train/41/77250/8868 +- membrane_hipsc_train/41/77333/9094 +- membrane_hipsc_train/42/106420/10373 +- membrane_hipsc_train/42/106421/10380 +- membrane_hipsc_train/42/106422/10368 +- membrane_hipsc_train/42/106516/10272 +- membrane_hipsc_train/42/106518/10239 +- membrane_hipsc_train/42/106520/10262 +- membrane_hipsc_train/42/106915/10747 +- membrane_hipsc_train/42/106996/10652 +- membrane_hipsc_train/42/106998/10641 +- membrane_hipsc_train/42/107480/10815 +- membrane_hipsc_train/42/107480/10822 +- membrane_hipsc_train/42/107572/12022 +- membrane_hipsc_train/42/107574/11982 +- membrane_hipsc_train/42/107574/12039 +- membrane_hipsc_train/42/107682/11895 +- membrane_hipsc_train/42/107682/11898 +- membrane_hipsc_train/42/107684/11928 +- membrane_hipsc_train/42/107956/11969 +- membrane_hipsc_train/42/107956/11981 +- membrane_hipsc_train/42/107958/11911 +- membrane_hipsc_train/42/107959/12029 +- membrane_hipsc_train/42/107972/11941 +- membrane_hipsc_train/42/108148/15673 +- membrane_hipsc_train/42/108149/12190 +- membrane_hipsc_train/42/108246/11135 +- membrane_hipsc_train/42/108248/16355 +- membrane_hipsc_train/42/108824/15581 +- membrane_hipsc_train/42/108833/15155 +- membrane_hipsc_train/42/110548/10130 +- membrane_hipsc_train/42/110552/10154 +- membrane_hipsc_train/42/110552/10175 +- membrane_hipsc_train/42/110645/10108 +- membrane_hipsc_train/42/110646/10124 +- membrane_hipsc_train/42/110660/10091 +- membrane_hipsc_train/42/110947/10199 +- membrane_hipsc_train/42/111125/10242 +- membrane_hipsc_train/42/111413/10485 +- membrane_hipsc_train/42/111415/10486 +- membrane_hipsc_train/42/111426/10473 +- membrane_hipsc_train/42/111892/10724 +- membrane_hipsc_train/42/112084/15061 +- membrane_hipsc_train/42/112085/16293 +- membrane_hipsc_train/42/112280/15454 +- membrane_hipsc_train/42/112565/10904 +- membrane_hipsc_train/42/112758/16064 +- membrane_hipsc_train/42/112772/14973 +- membrane_hipsc_train/42/113432/11852 +- membrane_hipsc_train/42/113634/10939 +- membrane_hipsc_train/42/113921/11053 +- membrane_hipsc_train/42/114209/10977 +- membrane_hipsc_train/42/114212/10981 +- membrane_hipsc_train/42/114787/11121 +- membrane_hipsc_train/42/114788/11097 +- membrane_hipsc_train/42/114965/11232 +- membrane_hipsc_train/42/114965/11269 +- membrane_hipsc_train/42/114979/11222 +- membrane_hipsc_train/42/115160/12126 +- membrane_hipsc_train/42/115169/16617 +- membrane_hipsc_train/42/115349/11410 +- membrane_hipsc_train/42/115541/15346 +- membrane_hipsc_train/42/115542/16879 +- membrane_hipsc_train/42/115552/15185 +- membrane_hipsc_train/42/115554/15716 +- membrane_hipsc_train/42/115555/16425 +- membrane_hipsc_train/42/115556/15703 +- membrane_hipsc_train/42/115831/11479 +- membrane_hipsc_train/42/116034/11497 +- membrane_hipsc_train/42/116309/11595 +- membrane_hipsc_train/42/116324/11616 +- membrane_hipsc_train/42/116608/10515 +- membrane_hipsc_train/42/116608/10614 +- membrane_hipsc_train/42/116887/10440 +- membrane_hipsc_train/42/116897/10412 +- membrane_hipsc_train/42/116900/10422 +- membrane_hipsc_train/42/117173/10673 +- membrane_hipsc_train/42/117186/10657 +- membrane_hipsc_train/42/117557/11347 +- membrane_hipsc_train/42/117559/11367 +- membrane_hipsc_train/42/117572/11385 +- membrane_hipsc_train/42/117847/11299 +- membrane_hipsc_train/42/118420/11731 +- membrane_hipsc_train/42/118423/11658 +- membrane_hipsc_train/42/118712/11569 +- membrane_hipsc_train/42/118806/11804 +- membrane_hipsc_train/42/118808/11800 +- membrane_hipsc_train/42/121791/16666 +- membrane_hipsc_train/42/121793/15852 +- membrane_hipsc_train/42/121806/15946 +- membrane_hipsc_train/42/123328/15550 +- membrane_hipsc_train/42/123328/17092 +- membrane_hipsc_train/42/123714/16851 +- membrane_hipsc_train/42/123903/15431 +- membrane_hipsc_train/42/124002/16132 +- membrane_hipsc_train/42/124014/16885 +- membrane_hipsc_train/42/124205/15565 +- membrane_hipsc_train/42/124287/15382 +- membrane_hipsc_train/42/124290/15483 +- membrane_hipsc_train/42/124291/15731 +- membrane_hipsc_train/42/124299/16712 +- membrane_hipsc_train/42/124301/15843 +- membrane_hipsc_train/42/127171/12333 +- membrane_hipsc_train/42/127647/12252 +- membrane_hipsc_train/42/127648/12223 +- membrane_hipsc_train/42/127649/12208 +- membrane_hipsc_train/42/127650/12238 +- membrane_hipsc_train/42/127650/12256 +- membrane_hipsc_train/42/127651/12217 +- membrane_hipsc_train/42/127651/12239 +- membrane_hipsc_train/42/127852/12320 +- membrane_hipsc_train/42/127935/12457 +- membrane_hipsc_train/42/127947/12485 +- membrane_hipsc_train/42/128416/12512 +- membrane_hipsc_train/42/128514/12657 +- membrane_hipsc_train/42/128514/12667 +- membrane_hipsc_train/42/128525/12654 +- membrane_hipsc_train/42/128715/12598 +- membrane_hipsc_train/42/128718/12626 +- membrane_hipsc_train/42/128719/12625 +- membrane_hipsc_train/42/129473/12830 +- membrane_hipsc_train/42/129473/12852 +- membrane_hipsc_train/42/129571/12811 +- membrane_hipsc_train/42/129583/12802 +- membrane_hipsc_train/42/129774/12715 +- membrane_hipsc_train/42/129855/12931 +- membrane_hipsc_train/42/130155/13043 +- membrane_hipsc_train/42/130527/12960 +- membrane_hipsc_train/42/130625/16186 +- membrane_hipsc_train/42/130707/13231 +- membrane_hipsc_train/42/130722/17097 +- membrane_hipsc_train/42/132173/13409 +- membrane_hipsc_train/42/132175/13365 +- membrane_hipsc_train/42/132653/13278 +- membrane_hipsc_train/42/132831/13415 +- membrane_hipsc_train/42/132844/13432 +- membrane_hipsc_train/42/132845/13448 +- membrane_hipsc_train/42/132929/13513 +- membrane_hipsc_train/42/133133/13640 +- membrane_hipsc_train/42/133323/13465 +- membrane_hipsc_train/42/133324/13457 +- membrane_hipsc_train/42/133325/13497 +- membrane_hipsc_train/42/133503/13577 +- membrane_hipsc_train/42/133504/13572 +- membrane_hipsc_train/42/133602/13711 +- membrane_hipsc_train/42/133711/13788 +- membrane_hipsc_train/42/134272/13918 +- membrane_hipsc_train/42/134286/13916 +- membrane_hipsc_train/42/134656/13884 +- membrane_hipsc_train/42/135272/14059 +- membrane_hipsc_train/42/135440/14128 +- membrane_hipsc_train/42/135525/14245 +- membrane_hipsc_train/42/135614/14178 +- membrane_hipsc_train/42/137434/14771 +- membrane_hipsc_train/42/137464/14708 +- membrane_hipsc_train/42/137767/14413 +- membrane_hipsc_train/42/137772/14516 +- membrane_hipsc_train/42/137956/15501 +- membrane_hipsc_train/42/137956/16613 +- membrane_hipsc_train/42/137956/17196 +- membrane_hipsc_train/42/137956/17224 +- membrane_hipsc_train/42/138024/15890 +- membrane_hipsc_train/42/138028/16174 +- membrane_hipsc_train/42/138032/15577 +- membrane_hipsc_train/42/138261/16083 +- membrane_hipsc_train/42/77912/9479 +- membrane_hipsc_train/42/77912/9520 +- membrane_hipsc_train/42/77923/9543 +- membrane_hipsc_train/42/78389/9675 +- membrane_hipsc_train/42/78391/9672 +- membrane_hipsc_train/42/78487/9750 +- membrane_hipsc_train/42/78487/9758 +- membrane_hipsc_train/42/78691/9802 +- membrane_hipsc_train/42/79541/9897 +- membrane_hipsc_train/42/79552/9894 +- membrane_hipsc_train/42/79554/9874 +- membrane_hipsc_train/42/79828/9972 +- membrane_hipsc_train/42/79831/9969 +- membrane_hipsc_train/42/79832/9978 +- membrane_hipsc_train/42/79841/9963 +- membrane_hipsc_train/42/80023/15006 +- membrane_hipsc_train/42/80033/15189 +- membrane_hipsc_train/42/80035/9980 +- membrane_hipsc_train/42/80224/9960 +- membrane_hipsc_train/42/83392/9630 +test_fovs: +- membrane_hipsc_test/4/11393/1428 +- membrane_hipsc_test/4/11479/1481 +- membrane_hipsc_test/4/18007/1641 +- membrane_hipsc_test/4/18102/1710 +- membrane_hipsc_test/4/18485/1842 +- membrane_hipsc_test/4/22901/3306 +- membrane_hipsc_test/4/27797/2857 +- membrane_hipsc_test/4/28759/3400 +- membrane_hipsc_test/4/29060/3786 +- membrane_hipsc_test/4/29140/3687 +- membrane_hipsc_test/4/29334/3890 +- membrane_hipsc_test/4/30293/3915 +- membrane_hipsc_test/4/31736/15232 +- membrane_hipsc_test/4/32024/4089 +- membrane_hipsc_test/4/34998/4271 +- membrane_hipsc_test/4/35284/4501 +- membrane_hipsc_test/4/36643/4930 +- membrane_hipsc_test/4/37601/5175 +- membrane_hipsc_test/4/38464/5176 +- membrane_hipsc_test/4/4556/15828 +- membrane_hipsc_test/4/4556/16242 +- membrane_hipsc_test/4/5910/824 +- membrane_hipsc_test/4/6497/1014 +- membrane_hipsc_test/4/6775/1242 +- membrane_hipsc_test/4/8706/1138 +- membrane_hipsc_test/4/94507/699 +- membrane_hipsc_test/41/44212/5751 +- membrane_hipsc_test/41/48436/5515 +- membrane_hipsc_test/41/48536/5593 +- membrane_hipsc_test/41/49121/5716 +- membrane_hipsc_test/41/49121/5777 +- membrane_hipsc_test/41/49204/5680 +- membrane_hipsc_test/41/49888/5888 +- membrane_hipsc_test/41/49975/5926 +- membrane_hipsc_test/41/50548/6016 +- membrane_hipsc_test/41/52564/5966 +- membrane_hipsc_test/41/53048/15203 +- membrane_hipsc_test/41/55160/6367 +- membrane_hipsc_test/41/55348/6437 +- membrane_hipsc_test/41/55350/6427 +- membrane_hipsc_test/41/58326/6874 +- membrane_hipsc_test/41/58517/6781 +- membrane_hipsc_test/41/60728/7413 +- membrane_hipsc_test/41/62754/7076 +- membrane_hipsc_test/41/63524/7359 +- membrane_hipsc_test/41/63524/7400 +- membrane_hipsc_test/41/63713/7287 +- membrane_hipsc_test/41/66020/7541 +- membrane_hipsc_test/41/67168/7688 +- membrane_hipsc_test/41/68116/7831 +- membrane_hipsc_test/41/68598/9132 +- membrane_hipsc_test/41/68804/8999 +- membrane_hipsc_test/41/68884/9247 +- membrane_hipsc_test/41/68885/9316 +- membrane_hipsc_test/41/70240/9487 +- membrane_hipsc_test/41/72356/7974 +- membrane_hipsc_test/41/72629/8071 +- membrane_hipsc_test/41/72725/8138 +- membrane_hipsc_test/41/72727/8125 +- membrane_hipsc_test/41/73112/8476 +- membrane_hipsc_test/41/73304/8259 +- membrane_hipsc_test/41/73686/8660 +- membrane_hipsc_test/41/73686/8668 +- membrane_hipsc_test/41/73783/8567 +- membrane_hipsc_test/41/74264/8751 +- membrane_hipsc_test/41/74272/8740 +- membrane_hipsc_test/41/74356/8919 +- membrane_hipsc_test/41/75800/8019 +- membrane_hipsc_test/41/75808/7975 +- membrane_hipsc_test/42/107478/10817 +- membrane_hipsc_test/42/114584/12053 +- membrane_hipsc_test/42/115556/15421 +- membrane_hipsc_test/42/116598/10604 +- membrane_hipsc_test/42/117557/11343 +- membrane_hipsc_test/42/118901/11674 +- membrane_hipsc_test/42/118912/11694 +- membrane_hipsc_test/42/123916/16655 +- membrane_hipsc_test/42/124001/16229 +- membrane_hipsc_test/42/127171/12338 +- membrane_hipsc_test/42/127276/23725 +- membrane_hipsc_test/42/127939/12482 +- membrane_hipsc_test/42/128428/12536 +- membrane_hipsc_test/42/128523/12637 +- membrane_hipsc_test/42/129665/12780 +- membrane_hipsc_test/42/129855/12890 +- membrane_hipsc_test/42/132463/13304 +- membrane_hipsc_test/42/132834/13446 +- membrane_hipsc_test/42/133599/13746 +- membrane_hipsc_test/42/135439/14132 +- membrane_hipsc_test/42/137449/14744 +- membrane_hipsc_test/42/137455/14731 +- membrane_hipsc_test/42/137460/14685 +- membrane_hipsc_test/42/137582/14642 +- membrane_hipsc_test/42/137774/14522 +- membrane_hipsc_test/42/137820/14488 +- membrane_hipsc_test/42/137953/15518 +- membrane_hipsc_test/42/77924/9512 +- membrane_hipsc_test/42/80023/9994 +- membrane_hipsc_test/42/82708/16181 +- membrane_hipsc_test/42/84449/15422 diff --git a/applications/dynacell/configs/collections/virtual_staining/membrane_joint_all_v1.yaml b/applications/dynacell/configs/collections/virtual_staining/membrane_joint_all_v1.yaml new file mode 100644 index 000000000..05a1bda92 --- /dev/null +++ b/applications/dynacell/configs/collections/virtual_staining/membrane_joint_all_v1.yaml @@ -0,0 +1,941 @@ +name: membrane_joint_all_v1 +description: Joint frozen benchmark collection across 2 selectors covering targets + 'caax', 'membrane'. Channels and FOV membership captured from the live train/test + zarr stores at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-27T12:03:43.986847+00:00' + created_by: Alex Kalinin +experiments: +- name: membrane_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Membrane + organelle: membrane + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: membrane_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Membrane + organelle: membrane + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: caax_a549_mantis_2026_03_26_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2026_03_26_A549_CAAX_H2B_DENV_ZIKV/train/CAAX.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Membrane + marker: CAAX + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: CAAX + organelle: membrane + pixel_size_xy_um: 0.116 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: caax_a549_mantis_2026_03_26_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2026_03_26_A549_CAAX_H2B_DENV_ZIKV/test/CAAX.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Membrane + marker: CAAX + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: CAAX + organelle: membrane + pixel_size_xy_um: 0.116 + pixel_size_z_um: 0.174 + exclude_fovs: [] +train_fovs: +- membrane_hipsc_train/4/10615/1304 +- membrane_hipsc_train/4/10625/1347 +- membrane_hipsc_train/4/10900/1427 +- membrane_hipsc_train/4/10904/1436 +- membrane_hipsc_train/4/11384/1404 +- membrane_hipsc_train/4/11478/1468 +- membrane_hipsc_train/4/11490/1466 +- membrane_hipsc_train/4/11492/1467 +- membrane_hipsc_train/4/11573/1414 +- membrane_hipsc_train/4/136707/16750 +- membrane_hipsc_train/4/136710/15363 +- membrane_hipsc_train/4/136721/16107 +- membrane_hipsc_train/4/136725/15834 +- membrane_hipsc_train/4/13974/1528 +- membrane_hipsc_train/4/14646/1871 +- membrane_hipsc_train/4/14740/1745 +- membrane_hipsc_train/4/14742/1791 +- membrane_hipsc_train/4/14754/1781 +- membrane_hipsc_train/4/1493/268 +- membrane_hipsc_train/4/1508/255 +- membrane_hipsc_train/4/16278/2186 +- membrane_hipsc_train/4/16376/2374 +- membrane_hipsc_train/4/16468/2321 +- membrane_hipsc_train/4/16469/2337 +- membrane_hipsc_train/4/16469/2339 +- membrane_hipsc_train/4/16469/2345 +- membrane_hipsc_train/4/16471/2265 +- membrane_hipsc_train/4/16472/2312 +- membrane_hipsc_train/4/16951/2459 +- membrane_hipsc_train/4/16951/2480 +- membrane_hipsc_train/4/16952/2494 +- membrane_hipsc_train/4/17333/2710 +- membrane_hipsc_train/4/17348/16148 +- membrane_hipsc_train/4/17525/2811 +- membrane_hipsc_train/4/17526/2752 +- membrane_hipsc_train/4/17536/2773 +- membrane_hipsc_train/4/18020/1618 +- membrane_hipsc_train/4/18020/1625 +- membrane_hipsc_train/4/18020/1638 +- membrane_hipsc_train/4/18487/1811 +- membrane_hipsc_train/4/19351/1905 +- membrane_hipsc_train/4/19543/2105 +- membrane_hipsc_train/4/19554/2020 +- membrane_hipsc_train/4/19556/2089 +- membrane_hipsc_train/4/20416/2223 +- membrane_hipsc_train/4/20596/2406 +- membrane_hipsc_train/4/20597/2395 +- membrane_hipsc_train/4/20597/2401 +- membrane_hipsc_train/4/20599/2373 +- membrane_hipsc_train/4/21077/2254 +- membrane_hipsc_train/4/21089/2293 +- membrane_hipsc_train/4/21556/2491 +- membrane_hipsc_train/4/21557/2483 +- membrane_hipsc_train/4/21557/2527 +- membrane_hipsc_train/4/21653/2547 +- membrane_hipsc_train/4/21860/15671 +- membrane_hipsc_train/4/21940/2736 +- membrane_hipsc_train/4/21943/2717 +- membrane_hipsc_train/4/21953/2739 +- membrane_hipsc_train/4/22133/2826 +- membrane_hipsc_train/4/22136/2827 +- membrane_hipsc_train/4/22339/3095 +- membrane_hipsc_train/4/22340/3097 +- membrane_hipsc_train/4/22612/2915 +- membrane_hipsc_train/4/22614/2923 +- membrane_hipsc_train/4/22615/2978 +- membrane_hipsc_train/4/22624/2909 +- membrane_hipsc_train/4/22709/3070 +- membrane_hipsc_train/4/22712/3090 +- membrane_hipsc_train/4/22913/3301 +- membrane_hipsc_train/4/22914/3289 +- membrane_hipsc_train/4/23380/3237 +- membrane_hipsc_train/4/23392/3212 +- membrane_hipsc_train/4/23395/3223 +- membrane_hipsc_train/4/23574/3492 +- membrane_hipsc_train/4/23764/3409 +- membrane_hipsc_train/4/24152/3567 +- membrane_hipsc_train/4/24724/3661 +- membrane_hipsc_train/4/24727/3659 +- membrane_hipsc_train/4/24928/3585 +- membrane_hipsc_train/4/25784/3851 +- membrane_hipsc_train/4/27800/2883 +- membrane_hipsc_train/4/27896/2943 +- membrane_hipsc_train/4/27992/3020 +- membrane_hipsc_train/4/28084/3214 +- membrane_hipsc_train/4/28084/3270 +- membrane_hipsc_train/4/28087/3266 +- membrane_hipsc_train/4/28756/3381 +- membrane_hipsc_train/4/28759/3393 +- membrane_hipsc_train/4/29045/3764 +- membrane_hipsc_train/4/29060/3753 +- membrane_hipsc_train/4/29143/3667 +- membrane_hipsc_train/4/29155/3710 +- membrane_hipsc_train/4/2932/230 +- membrane_hipsc_train/4/29333/3908 +- membrane_hipsc_train/4/2945/173 +- membrane_hipsc_train/4/30292/14379 +- membrane_hipsc_train/4/30293/3905 +- membrane_hipsc_train/4/30308/3869 +- membrane_hipsc_train/4/30388/16862 +- membrane_hipsc_train/4/30389/15342 +- membrane_hipsc_train/4/30392/16741 +- membrane_hipsc_train/4/31732/17059 +- membrane_hipsc_train/4/31744/16779 +- membrane_hipsc_train/4/31841/3962 +- membrane_hipsc_train/4/31939/3975 +- membrane_hipsc_train/4/32024/4077 +- membrane_hipsc_train/4/32033/4111 +- membrane_hipsc_train/4/32033/4121 +- membrane_hipsc_train/4/32035/4099 +- membrane_hipsc_train/4/33077/4379 +- membrane_hipsc_train/4/33572/4229 +- membrane_hipsc_train/4/33942/15337 +- membrane_hipsc_train/4/33942/16205 +- membrane_hipsc_train/4/33943/17061 +- membrane_hipsc_train/4/33953/16561 +- membrane_hipsc_train/4/33955/16023 +- membrane_hipsc_train/4/34038/4363 +- membrane_hipsc_train/4/34808/4417 +- membrane_hipsc_train/4/35000/4274 +- membrane_hipsc_train/4/35284/4472 +- membrane_hipsc_train/4/35287/4460 +- membrane_hipsc_train/4/35479/4551 +- membrane_hipsc_train/4/35489/4583 +- membrane_hipsc_train/4/36449/15327 +- membrane_hipsc_train/4/36544/4909 +- membrane_hipsc_train/4/36544/4931 +- membrane_hipsc_train/4/36628/4907 +- membrane_hipsc_train/4/36836/4996 +- membrane_hipsc_train/4/37591/5133 +- membrane_hipsc_train/4/37603/5147 +- membrane_hipsc_train/4/37972/5388 +- membrane_hipsc_train/4/37988/5373 +- membrane_hipsc_train/4/40084/5359 +- membrane_hipsc_train/4/40086/5362 +- membrane_hipsc_train/4/40376/4584 +- membrane_hipsc_train/4/40385/4614 +- membrane_hipsc_train/4/40386/4613 +- membrane_hipsc_train/4/40387/4586 +- membrane_hipsc_train/4/40483/4619 +- membrane_hipsc_train/4/40483/4621 +- membrane_hipsc_train/4/40960/4654 +- membrane_hipsc_train/4/41044/4851 +- membrane_hipsc_train/4/41047/4885 +- membrane_hipsc_train/4/41237/4861 +- membrane_hipsc_train/4/41249/4835 +- membrane_hipsc_train/4/41912/5074 +- membrane_hipsc_train/4/5143/954 +- membrane_hipsc_train/4/5236/869 +- membrane_hipsc_train/4/5238/875 +- membrane_hipsc_train/4/6485/1018 +- membrane_hipsc_train/4/6486/992 +- membrane_hipsc_train/4/6497/1003 +- membrane_hipsc_train/4/6775/1203 +- membrane_hipsc_train/4/6775/1226 +- membrane_hipsc_train/4/6775/1236 +- membrane_hipsc_train/4/7156/1124 +- membrane_hipsc_train/4/7349/1355 +- membrane_hipsc_train/4/7650/1278 +- membrane_hipsc_train/4/8214/878 +- membrane_hipsc_train/4/8214/879 +- membrane_hipsc_train/4/8228/898 +- membrane_hipsc_train/4/8695/1215 +- membrane_hipsc_train/4/88267/15294 +- membrane_hipsc_train/4/89048/356 +- membrane_hipsc_train/4/8982/1171 +- membrane_hipsc_train/4/90088/415 +- membrane_hipsc_train/4/90858/15658 +- membrane_hipsc_train/4/90858/16534 +- membrane_hipsc_train/4/91144/102 +- membrane_hipsc_train/4/91924/458 +- membrane_hipsc_train/4/93448/596 +- membrane_hipsc_train/4/94312/684 +- membrane_hipsc_train/4/95752/811 +- membrane_hipsc_train/4/95753/737 +- membrane_hipsc_train/4/95753/872 +- membrane_hipsc_train/41/43638/5246 +- membrane_hipsc_train/41/43639/5265 +- membrane_hipsc_train/41/43732/16519 +- membrane_hipsc_train/41/45556/5706 +- membrane_hipsc_train/41/45556/5734 +- membrane_hipsc_train/41/45559/5714 +- membrane_hipsc_train/41/48436/5507 +- membrane_hipsc_train/41/48534/5575 +- membrane_hipsc_train/41/48535/5623 +- membrane_hipsc_train/41/48548/5574 +- membrane_hipsc_train/41/48548/5589 +- membrane_hipsc_train/41/49204/5661 +- membrane_hipsc_train/41/49220/5671 +- membrane_hipsc_train/41/49698/5819 +- membrane_hipsc_train/41/49972/5933 +- membrane_hipsc_train/41/49973/5960 +- membrane_hipsc_train/41/50263/6077 +- membrane_hipsc_train/41/50263/6082 +- membrane_hipsc_train/41/50356/15510 +- membrane_hipsc_train/41/50356/15578 +- membrane_hipsc_train/41/50359/15457 +- membrane_hipsc_train/41/50548/6024 +- membrane_hipsc_train/41/50551/6022 +- membrane_hipsc_train/41/53044/15243 +- membrane_hipsc_train/41/53046/16965 +- membrane_hipsc_train/41/53428/6238 +- membrane_hipsc_train/41/53524/15636 +- membrane_hipsc_train/41/53538/15395 +- membrane_hipsc_train/41/53731/15920 +- membrane_hipsc_train/41/55156/6355 +- membrane_hipsc_train/41/55156/6358 +- membrane_hipsc_train/41/55158/6324 +- membrane_hipsc_train/41/55158/6353 +- membrane_hipsc_train/41/55253/6499 +- membrane_hipsc_train/41/55256/6482 +- membrane_hipsc_train/41/55351/6419 +- membrane_hipsc_train/41/55363/6362 +- membrane_hipsc_train/41/55925/6584 +- membrane_hipsc_train/41/56406/6643 +- membrane_hipsc_train/41/56416/6614 +- membrane_hipsc_train/41/56418/6626 +- membrane_hipsc_train/41/56419/6630 +- membrane_hipsc_train/41/56596/6678 +- membrane_hipsc_train/41/56896/7720 +- membrane_hipsc_train/41/57364/6456 +- membrane_hipsc_train/41/57365/6428 +- membrane_hipsc_train/41/57367/6430 +- membrane_hipsc_train/41/57464/6544 +- membrane_hipsc_train/41/57472/6556 +- membrane_hipsc_train/41/57472/6565 +- membrane_hipsc_train/41/58134/6821 +- membrane_hipsc_train/41/58326/6840 +- membrane_hipsc_train/41/58420/6971 +- membrane_hipsc_train/41/58423/6963 +- membrane_hipsc_train/41/58518/6786 +- membrane_hipsc_train/41/59285/7118 +- membrane_hipsc_train/41/59285/7124 +- membrane_hipsc_train/41/59298/7175 +- membrane_hipsc_train/41/59380/7015 +- membrane_hipsc_train/41/59479/7188 +- membrane_hipsc_train/41/59479/7200 +- membrane_hipsc_train/41/59480/7179 +- membrane_hipsc_train/41/60548/7475 +- membrane_hipsc_train/41/60632/7345 +- membrane_hipsc_train/41/60726/7399 +- membrane_hipsc_train/41/60737/7332 +- membrane_hipsc_train/41/60738/7414 +- membrane_hipsc_train/41/62740/7068 +- membrane_hipsc_train/41/62932/6916 +- membrane_hipsc_train/41/63508/7389 +- membrane_hipsc_train/41/63523/7383 +- membrane_hipsc_train/41/63608/7462 +- membrane_hipsc_train/41/63608/7464 +- membrane_hipsc_train/41/63620/7451 +- membrane_hipsc_train/41/63701/7283 +- membrane_hipsc_train/41/63713/7256 +- membrane_hipsc_train/41/66292/7775 +- membrane_hipsc_train/41/66292/7782 +- membrane_hipsc_train/41/66292/7796 +- membrane_hipsc_train/41/66296/7788 +- membrane_hipsc_train/41/67157/7690 +- membrane_hipsc_train/41/67168/7678 +- membrane_hipsc_train/41/68131/7834 +- membrane_hipsc_train/41/68503/9206 +- membrane_hipsc_train/41/68504/9176 +- membrane_hipsc_train/41/68504/9197 +- membrane_hipsc_train/41/68512/9188 +- membrane_hipsc_train/41/68512/9207 +- membrane_hipsc_train/41/68512/9212 +- membrane_hipsc_train/41/68708/9065 +- membrane_hipsc_train/41/68788/9030 +- membrane_hipsc_train/41/68800/9019 +- membrane_hipsc_train/41/69472/9285 +- membrane_hipsc_train/41/69473/9279 +- membrane_hipsc_train/41/69474/9306 +- membrane_hipsc_train/41/70052/15689 +- membrane_hipsc_train/41/70231/9525 +- membrane_hipsc_train/41/70232/9551 +- membrane_hipsc_train/41/72244/8037 +- membrane_hipsc_train/41/72244/8074 +- membrane_hipsc_train/41/72256/8049 +- membrane_hipsc_train/41/72260/8085 +- membrane_hipsc_train/41/72342/7994 +- membrane_hipsc_train/41/72356/7962 +- membrane_hipsc_train/41/72628/8109 +- membrane_hipsc_train/41/72629/8086 +- membrane_hipsc_train/41/72630/8119 +- membrane_hipsc_train/41/72631/8095 +- membrane_hipsc_train/41/72725/8151 +- membrane_hipsc_train/41/72726/8128 +- membrane_hipsc_train/41/72834/8288 +- membrane_hipsc_train/41/73300/8255 +- membrane_hipsc_train/41/73396/8265 +- membrane_hipsc_train/41/73397/8271 +- membrane_hipsc_train/41/73398/8307 +- membrane_hipsc_train/41/73495/8186 +- membrane_hipsc_train/41/73507/8203 +- membrane_hipsc_train/41/73685/8634 +- membrane_hipsc_train/41/73687/8628 +- membrane_hipsc_train/41/73700/8663 +- membrane_hipsc_train/41/73782/8525 +- membrane_hipsc_train/41/73782/8576 +- membrane_hipsc_train/41/73783/8530 +- membrane_hipsc_train/41/73784/8543 +- membrane_hipsc_train/41/73879/15995 +- membrane_hipsc_train/41/73975/15832 +- membrane_hipsc_train/41/74165/8821 +- membrane_hipsc_train/41/74168/8793 +- membrane_hipsc_train/41/74260/8727 +- membrane_hipsc_train/41/74273/8721 +- membrane_hipsc_train/41/74371/8941 +- membrane_hipsc_train/41/74371/8978 +- membrane_hipsc_train/41/75042/7915 +- membrane_hipsc_train/41/75124/16978 +- membrane_hipsc_train/41/75125/16693 +- membrane_hipsc_train/41/75512/7872 +- membrane_hipsc_train/41/75796/7941 +- membrane_hipsc_train/41/75799/7953 +- membrane_hipsc_train/41/76000/8244 +- membrane_hipsc_train/41/77250/8868 +- membrane_hipsc_train/41/77333/9094 +- membrane_hipsc_train/42/106420/10373 +- membrane_hipsc_train/42/106421/10380 +- membrane_hipsc_train/42/106422/10368 +- membrane_hipsc_train/42/106516/10272 +- membrane_hipsc_train/42/106518/10239 +- membrane_hipsc_train/42/106520/10262 +- membrane_hipsc_train/42/106915/10747 +- membrane_hipsc_train/42/106996/10652 +- membrane_hipsc_train/42/106998/10641 +- membrane_hipsc_train/42/107480/10815 +- membrane_hipsc_train/42/107480/10822 +- membrane_hipsc_train/42/107572/12022 +- membrane_hipsc_train/42/107574/11982 +- membrane_hipsc_train/42/107574/12039 +- membrane_hipsc_train/42/107682/11895 +- membrane_hipsc_train/42/107682/11898 +- membrane_hipsc_train/42/107684/11928 +- membrane_hipsc_train/42/107956/11969 +- membrane_hipsc_train/42/107956/11981 +- membrane_hipsc_train/42/107958/11911 +- membrane_hipsc_train/42/107959/12029 +- membrane_hipsc_train/42/107972/11941 +- membrane_hipsc_train/42/108148/15673 +- membrane_hipsc_train/42/108149/12190 +- membrane_hipsc_train/42/108246/11135 +- membrane_hipsc_train/42/108248/16355 +- membrane_hipsc_train/42/108824/15581 +- membrane_hipsc_train/42/108833/15155 +- membrane_hipsc_train/42/110548/10130 +- membrane_hipsc_train/42/110552/10154 +- membrane_hipsc_train/42/110552/10175 +- membrane_hipsc_train/42/110645/10108 +- membrane_hipsc_train/42/110646/10124 +- membrane_hipsc_train/42/110660/10091 +- membrane_hipsc_train/42/110947/10199 +- membrane_hipsc_train/42/111125/10242 +- membrane_hipsc_train/42/111413/10485 +- membrane_hipsc_train/42/111415/10486 +- membrane_hipsc_train/42/111426/10473 +- membrane_hipsc_train/42/111892/10724 +- membrane_hipsc_train/42/112084/15061 +- membrane_hipsc_train/42/112085/16293 +- membrane_hipsc_train/42/112280/15454 +- membrane_hipsc_train/42/112565/10904 +- membrane_hipsc_train/42/112758/16064 +- membrane_hipsc_train/42/112772/14973 +- membrane_hipsc_train/42/113432/11852 +- membrane_hipsc_train/42/113634/10939 +- membrane_hipsc_train/42/113921/11053 +- membrane_hipsc_train/42/114209/10977 +- membrane_hipsc_train/42/114212/10981 +- membrane_hipsc_train/42/114787/11121 +- membrane_hipsc_train/42/114788/11097 +- membrane_hipsc_train/42/114965/11232 +- membrane_hipsc_train/42/114965/11269 +- membrane_hipsc_train/42/114979/11222 +- membrane_hipsc_train/42/115160/12126 +- membrane_hipsc_train/42/115169/16617 +- membrane_hipsc_train/42/115349/11410 +- membrane_hipsc_train/42/115541/15346 +- membrane_hipsc_train/42/115542/16879 +- membrane_hipsc_train/42/115552/15185 +- membrane_hipsc_train/42/115554/15716 +- membrane_hipsc_train/42/115555/16425 +- membrane_hipsc_train/42/115556/15703 +- membrane_hipsc_train/42/115831/11479 +- membrane_hipsc_train/42/116034/11497 +- membrane_hipsc_train/42/116309/11595 +- membrane_hipsc_train/42/116324/11616 +- membrane_hipsc_train/42/116608/10515 +- membrane_hipsc_train/42/116608/10614 +- membrane_hipsc_train/42/116887/10440 +- membrane_hipsc_train/42/116897/10412 +- membrane_hipsc_train/42/116900/10422 +- membrane_hipsc_train/42/117173/10673 +- membrane_hipsc_train/42/117186/10657 +- membrane_hipsc_train/42/117557/11347 +- membrane_hipsc_train/42/117559/11367 +- membrane_hipsc_train/42/117572/11385 +- membrane_hipsc_train/42/117847/11299 +- membrane_hipsc_train/42/118420/11731 +- membrane_hipsc_train/42/118423/11658 +- membrane_hipsc_train/42/118712/11569 +- membrane_hipsc_train/42/118806/11804 +- membrane_hipsc_train/42/118808/11800 +- membrane_hipsc_train/42/121791/16666 +- membrane_hipsc_train/42/121793/15852 +- membrane_hipsc_train/42/121806/15946 +- membrane_hipsc_train/42/123328/15550 +- membrane_hipsc_train/42/123328/17092 +- membrane_hipsc_train/42/123714/16851 +- membrane_hipsc_train/42/123903/15431 +- membrane_hipsc_train/42/124002/16132 +- membrane_hipsc_train/42/124014/16885 +- membrane_hipsc_train/42/124205/15565 +- membrane_hipsc_train/42/124287/15382 +- membrane_hipsc_train/42/124290/15483 +- membrane_hipsc_train/42/124291/15731 +- membrane_hipsc_train/42/124299/16712 +- membrane_hipsc_train/42/124301/15843 +- membrane_hipsc_train/42/127171/12333 +- membrane_hipsc_train/42/127647/12252 +- membrane_hipsc_train/42/127648/12223 +- membrane_hipsc_train/42/127649/12208 +- membrane_hipsc_train/42/127650/12238 +- membrane_hipsc_train/42/127650/12256 +- membrane_hipsc_train/42/127651/12217 +- membrane_hipsc_train/42/127651/12239 +- membrane_hipsc_train/42/127852/12320 +- membrane_hipsc_train/42/127935/12457 +- membrane_hipsc_train/42/127947/12485 +- membrane_hipsc_train/42/128416/12512 +- membrane_hipsc_train/42/128514/12657 +- membrane_hipsc_train/42/128514/12667 +- membrane_hipsc_train/42/128525/12654 +- membrane_hipsc_train/42/128715/12598 +- membrane_hipsc_train/42/128718/12626 +- membrane_hipsc_train/42/128719/12625 +- membrane_hipsc_train/42/129473/12830 +- membrane_hipsc_train/42/129473/12852 +- membrane_hipsc_train/42/129571/12811 +- membrane_hipsc_train/42/129583/12802 +- membrane_hipsc_train/42/129774/12715 +- membrane_hipsc_train/42/129855/12931 +- membrane_hipsc_train/42/130155/13043 +- membrane_hipsc_train/42/130527/12960 +- membrane_hipsc_train/42/130625/16186 +- membrane_hipsc_train/42/130707/13231 +- membrane_hipsc_train/42/130722/17097 +- membrane_hipsc_train/42/132173/13409 +- membrane_hipsc_train/42/132175/13365 +- membrane_hipsc_train/42/132653/13278 +- membrane_hipsc_train/42/132831/13415 +- membrane_hipsc_train/42/132844/13432 +- membrane_hipsc_train/42/132845/13448 +- membrane_hipsc_train/42/132929/13513 +- membrane_hipsc_train/42/133133/13640 +- membrane_hipsc_train/42/133323/13465 +- membrane_hipsc_train/42/133324/13457 +- membrane_hipsc_train/42/133325/13497 +- membrane_hipsc_train/42/133503/13577 +- membrane_hipsc_train/42/133504/13572 +- membrane_hipsc_train/42/133602/13711 +- membrane_hipsc_train/42/133711/13788 +- membrane_hipsc_train/42/134272/13918 +- membrane_hipsc_train/42/134286/13916 +- membrane_hipsc_train/42/134656/13884 +- membrane_hipsc_train/42/135272/14059 +- membrane_hipsc_train/42/135440/14128 +- membrane_hipsc_train/42/135525/14245 +- membrane_hipsc_train/42/135614/14178 +- membrane_hipsc_train/42/137434/14771 +- membrane_hipsc_train/42/137464/14708 +- membrane_hipsc_train/42/137767/14413 +- membrane_hipsc_train/42/137772/14516 +- membrane_hipsc_train/42/137956/15501 +- membrane_hipsc_train/42/137956/16613 +- membrane_hipsc_train/42/137956/17196 +- membrane_hipsc_train/42/137956/17224 +- membrane_hipsc_train/42/138024/15890 +- membrane_hipsc_train/42/138028/16174 +- membrane_hipsc_train/42/138032/15577 +- membrane_hipsc_train/42/138261/16083 +- membrane_hipsc_train/42/77912/9479 +- membrane_hipsc_train/42/77912/9520 +- membrane_hipsc_train/42/77923/9543 +- membrane_hipsc_train/42/78389/9675 +- membrane_hipsc_train/42/78391/9672 +- membrane_hipsc_train/42/78487/9750 +- membrane_hipsc_train/42/78487/9758 +- membrane_hipsc_train/42/78691/9802 +- membrane_hipsc_train/42/79541/9897 +- membrane_hipsc_train/42/79552/9894 +- membrane_hipsc_train/42/79554/9874 +- membrane_hipsc_train/42/79828/9972 +- membrane_hipsc_train/42/79831/9969 +- membrane_hipsc_train/42/79832/9978 +- membrane_hipsc_train/42/79841/9963 +- membrane_hipsc_train/42/80023/15006 +- membrane_hipsc_train/42/80033/15189 +- membrane_hipsc_train/42/80035/9980 +- membrane_hipsc_train/42/80224/9960 +- membrane_hipsc_train/42/83392/9630 +- caax_a549_mantis_2026_03_26_train/B/2/000002 +- caax_a549_mantis_2026_03_26_train/B/2/000003 +- caax_a549_mantis_2026_03_26_train/B/2/000005 +- caax_a549_mantis_2026_03_26_train/B/2/000006 +- caax_a549_mantis_2026_03_26_train/B/2/000008 +- caax_a549_mantis_2026_03_26_train/B/2/001000 +- caax_a549_mantis_2026_03_26_train/B/2/001001 +- caax_a549_mantis_2026_03_26_train/B/2/001002 +- caax_a549_mantis_2026_03_26_train/B/2/001003 +- caax_a549_mantis_2026_03_26_train/B/2/001004 +- caax_a549_mantis_2026_03_26_train/B/2/001005 +- caax_a549_mantis_2026_03_26_train/B/2/001006 +- caax_a549_mantis_2026_03_26_train/B/2/001007 +- caax_a549_mantis_2026_03_26_train/B/2/001008 +- caax_a549_mantis_2026_03_26_train/B/2/002000 +- caax_a549_mantis_2026_03_26_train/B/2/002001 +- caax_a549_mantis_2026_03_26_train/B/2/002002 +- caax_a549_mantis_2026_03_26_train/B/2/002003 +- caax_a549_mantis_2026_03_26_train/B/2/002004 +- caax_a549_mantis_2026_03_26_train/B/2/002005 +- caax_a549_mantis_2026_03_26_train/B/2/002006 +- caax_a549_mantis_2026_03_26_train/B/2/002007 +- caax_a549_mantis_2026_03_26_train/B/2/002008 +- caax_a549_mantis_2026_03_26_train/B/2/003000 +- caax_a549_mantis_2026_03_26_train/B/2/003002 +- caax_a549_mantis_2026_03_26_train/B/2/003003 +- caax_a549_mantis_2026_03_26_train/B/2/003005 +- caax_a549_mantis_2026_03_26_train/B/2/003006 +- caax_a549_mantis_2026_03_26_train/B/2/003008 +- caax_a549_mantis_2026_03_26_train/B/2/004000 +- caax_a549_mantis_2026_03_26_train/B/2/004001 +- caax_a549_mantis_2026_03_26_train/B/2/004002 +- caax_a549_mantis_2026_03_26_train/B/2/004003 +- caax_a549_mantis_2026_03_26_train/B/2/004004 +- caax_a549_mantis_2026_03_26_train/B/2/004005 +- caax_a549_mantis_2026_03_26_train/B/2/004006 +- caax_a549_mantis_2026_03_26_train/B/2/004007 +- caax_a549_mantis_2026_03_26_train/B/2/004008 +- caax_a549_mantis_2026_03_26_train/B/2/005000 +- caax_a549_mantis_2026_03_26_train/B/2/005002 +- caax_a549_mantis_2026_03_26_train/B/2/005003 +- caax_a549_mantis_2026_03_26_train/B/2/005005 +- caax_a549_mantis_2026_03_26_train/B/2/005006 +- caax_a549_mantis_2026_03_26_train/B/2/005008 +- caax_a549_mantis_2026_03_26_train/B/2/006000 +- caax_a549_mantis_2026_03_26_train/B/2/006001 +- caax_a549_mantis_2026_03_26_train/B/2/006002 +- caax_a549_mantis_2026_03_26_train/B/2/006003 +- caax_a549_mantis_2026_03_26_train/B/2/006004 +- caax_a549_mantis_2026_03_26_train/B/2/006005 +- caax_a549_mantis_2026_03_26_train/B/2/006006 +- caax_a549_mantis_2026_03_26_train/B/2/006007 +- caax_a549_mantis_2026_03_26_train/B/2/006008 +- caax_a549_mantis_2026_03_26_train/B/2/007000 +- caax_a549_mantis_2026_03_26_train/B/2/007001 +- caax_a549_mantis_2026_03_26_train/B/2/007002 +- caax_a549_mantis_2026_03_26_train/B/2/007003 +- caax_a549_mantis_2026_03_26_train/B/2/007004 +- caax_a549_mantis_2026_03_26_train/B/2/007005 +- caax_a549_mantis_2026_03_26_train/B/2/007006 +- caax_a549_mantis_2026_03_26_train/B/2/007007 +- caax_a549_mantis_2026_03_26_train/B/2/007008 +- caax_a549_mantis_2026_03_26_train/B/2/008000 +- caax_a549_mantis_2026_03_26_train/B/2/008002 +- caax_a549_mantis_2026_03_26_train/B/2/008003 +- caax_a549_mantis_2026_03_26_train/B/2/008005 +- caax_a549_mantis_2026_03_26_train/B/2/008006 +- caax_a549_mantis_2026_03_26_train/B/2/008008 +- caax_a549_mantis_2026_03_26_train/B/3/000000 +- caax_a549_mantis_2026_03_26_train/B/3/000002 +- caax_a549_mantis_2026_03_26_train/B/3/000003 +- caax_a549_mantis_2026_03_26_train/B/3/000005 +- caax_a549_mantis_2026_03_26_train/B/3/000006 +- caax_a549_mantis_2026_03_26_train/B/3/000008 +- caax_a549_mantis_2026_03_26_train/B/3/001000 +- caax_a549_mantis_2026_03_26_train/B/3/001001 +- caax_a549_mantis_2026_03_26_train/B/3/001002 +- caax_a549_mantis_2026_03_26_train/B/3/001003 +- caax_a549_mantis_2026_03_26_train/B/3/001004 +- caax_a549_mantis_2026_03_26_train/B/3/001005 +- caax_a549_mantis_2026_03_26_train/B/3/001006 +- caax_a549_mantis_2026_03_26_train/B/3/001007 +- caax_a549_mantis_2026_03_26_train/B/3/001008 +- caax_a549_mantis_2026_03_26_train/B/3/002000 +- caax_a549_mantis_2026_03_26_train/B/3/002001 +- caax_a549_mantis_2026_03_26_train/B/3/002002 +- caax_a549_mantis_2026_03_26_train/B/3/002003 +- caax_a549_mantis_2026_03_26_train/B/3/002004 +- caax_a549_mantis_2026_03_26_train/B/3/002005 +- caax_a549_mantis_2026_03_26_train/B/3/002006 +- caax_a549_mantis_2026_03_26_train/B/3/002007 +- caax_a549_mantis_2026_03_26_train/B/3/002008 +- caax_a549_mantis_2026_03_26_train/B/3/003000 +- caax_a549_mantis_2026_03_26_train/B/3/003002 +- caax_a549_mantis_2026_03_26_train/B/3/003003 +- caax_a549_mantis_2026_03_26_train/B/3/003005 +- caax_a549_mantis_2026_03_26_train/B/3/003006 +- caax_a549_mantis_2026_03_26_train/B/3/003008 +- caax_a549_mantis_2026_03_26_train/B/3/004000 +- caax_a549_mantis_2026_03_26_train/B/3/004001 +- caax_a549_mantis_2026_03_26_train/B/3/004002 +- caax_a549_mantis_2026_03_26_train/B/3/004003 +- caax_a549_mantis_2026_03_26_train/B/3/004004 +- caax_a549_mantis_2026_03_26_train/B/3/004005 +- caax_a549_mantis_2026_03_26_train/B/3/004006 +- caax_a549_mantis_2026_03_26_train/B/3/004007 +- caax_a549_mantis_2026_03_26_train/B/3/004008 +- caax_a549_mantis_2026_03_26_train/B/3/005000 +- caax_a549_mantis_2026_03_26_train/B/3/005002 +- caax_a549_mantis_2026_03_26_train/B/3/005003 +- caax_a549_mantis_2026_03_26_train/B/3/005005 +- caax_a549_mantis_2026_03_26_train/B/3/005006 +- caax_a549_mantis_2026_03_26_train/B/3/005008 +- caax_a549_mantis_2026_03_26_train/B/3/006000 +- caax_a549_mantis_2026_03_26_train/B/3/006001 +- caax_a549_mantis_2026_03_26_train/B/3/006002 +- caax_a549_mantis_2026_03_26_train/B/3/006003 +- caax_a549_mantis_2026_03_26_train/B/3/006004 +- caax_a549_mantis_2026_03_26_train/B/3/006005 +- caax_a549_mantis_2026_03_26_train/B/3/006006 +- caax_a549_mantis_2026_03_26_train/B/3/006007 +- caax_a549_mantis_2026_03_26_train/B/3/006008 +- caax_a549_mantis_2026_03_26_train/B/3/007000 +- caax_a549_mantis_2026_03_26_train/B/3/007001 +- caax_a549_mantis_2026_03_26_train/B/3/007002 +- caax_a549_mantis_2026_03_26_train/B/3/007003 +- caax_a549_mantis_2026_03_26_train/B/3/007004 +- caax_a549_mantis_2026_03_26_train/B/3/007005 +- caax_a549_mantis_2026_03_26_train/B/3/007006 +- caax_a549_mantis_2026_03_26_train/B/3/007007 +- caax_a549_mantis_2026_03_26_train/B/3/007008 +- caax_a549_mantis_2026_03_26_train/B/3/008000 +- caax_a549_mantis_2026_03_26_train/B/3/008002 +- caax_a549_mantis_2026_03_26_train/B/3/008003 +- caax_a549_mantis_2026_03_26_train/B/3/008005 +- caax_a549_mantis_2026_03_26_train/B/3/008006 +- caax_a549_mantis_2026_03_26_train/B/3/008008 +- caax_a549_mantis_2026_03_26_train/B/4/000000 +- caax_a549_mantis_2026_03_26_train/B/4/000002 +- caax_a549_mantis_2026_03_26_train/B/4/000003 +- caax_a549_mantis_2026_03_26_train/B/4/000005 +- caax_a549_mantis_2026_03_26_train/B/4/000006 +- caax_a549_mantis_2026_03_26_train/B/4/000008 +- caax_a549_mantis_2026_03_26_train/B/4/001000 +- caax_a549_mantis_2026_03_26_train/B/4/001001 +- caax_a549_mantis_2026_03_26_train/B/4/001002 +- caax_a549_mantis_2026_03_26_train/B/4/001003 +- caax_a549_mantis_2026_03_26_train/B/4/001004 +- caax_a549_mantis_2026_03_26_train/B/4/001005 +- caax_a549_mantis_2026_03_26_train/B/4/001006 +- caax_a549_mantis_2026_03_26_train/B/4/001007 +- caax_a549_mantis_2026_03_26_train/B/4/001008 +- caax_a549_mantis_2026_03_26_train/B/4/002000 +- caax_a549_mantis_2026_03_26_train/B/4/002001 +- caax_a549_mantis_2026_03_26_train/B/4/002002 +- caax_a549_mantis_2026_03_26_train/B/4/002003 +- caax_a549_mantis_2026_03_26_train/B/4/002004 +- caax_a549_mantis_2026_03_26_train/B/4/002005 +- caax_a549_mantis_2026_03_26_train/B/4/002006 +- caax_a549_mantis_2026_03_26_train/B/4/002007 +- caax_a549_mantis_2026_03_26_train/B/4/002008 +- caax_a549_mantis_2026_03_26_train/B/4/003000 +- caax_a549_mantis_2026_03_26_train/B/4/003002 +- caax_a549_mantis_2026_03_26_train/B/4/003003 +- caax_a549_mantis_2026_03_26_train/B/4/003005 +- caax_a549_mantis_2026_03_26_train/B/4/003006 +- caax_a549_mantis_2026_03_26_train/B/4/003008 +- caax_a549_mantis_2026_03_26_train/B/4/004000 +- caax_a549_mantis_2026_03_26_train/B/4/004001 +- caax_a549_mantis_2026_03_26_train/B/4/004002 +- caax_a549_mantis_2026_03_26_train/B/4/004003 +- caax_a549_mantis_2026_03_26_train/B/4/004004 +- caax_a549_mantis_2026_03_26_train/B/4/004005 +- caax_a549_mantis_2026_03_26_train/B/4/004006 +- caax_a549_mantis_2026_03_26_train/B/4/004007 +- caax_a549_mantis_2026_03_26_train/B/4/004008 +- caax_a549_mantis_2026_03_26_train/B/4/005000 +- caax_a549_mantis_2026_03_26_train/B/4/005002 +- caax_a549_mantis_2026_03_26_train/B/4/005003 +- caax_a549_mantis_2026_03_26_train/B/4/005005 +- caax_a549_mantis_2026_03_26_train/B/4/005006 +- caax_a549_mantis_2026_03_26_train/B/4/005008 +- caax_a549_mantis_2026_03_26_train/B/4/006000 +- caax_a549_mantis_2026_03_26_train/B/4/006001 +- caax_a549_mantis_2026_03_26_train/B/4/006002 +- caax_a549_mantis_2026_03_26_train/B/4/006003 +- caax_a549_mantis_2026_03_26_train/B/4/006004 +- caax_a549_mantis_2026_03_26_train/B/4/006005 +- caax_a549_mantis_2026_03_26_train/B/4/006006 +- caax_a549_mantis_2026_03_26_train/B/4/006007 +- caax_a549_mantis_2026_03_26_train/B/4/006008 +- caax_a549_mantis_2026_03_26_train/B/4/007000 +- caax_a549_mantis_2026_03_26_train/B/4/007001 +- caax_a549_mantis_2026_03_26_train/B/4/007002 +- caax_a549_mantis_2026_03_26_train/B/4/007003 +- caax_a549_mantis_2026_03_26_train/B/4/007004 +- caax_a549_mantis_2026_03_26_train/B/4/007005 +- caax_a549_mantis_2026_03_26_train/B/4/007006 +- caax_a549_mantis_2026_03_26_train/B/4/007007 +- caax_a549_mantis_2026_03_26_train/B/4/007008 +- caax_a549_mantis_2026_03_26_train/B/4/008000 +- caax_a549_mantis_2026_03_26_train/B/4/008002 +- caax_a549_mantis_2026_03_26_train/B/4/008003 +- caax_a549_mantis_2026_03_26_train/B/4/008005 +- caax_a549_mantis_2026_03_26_train/B/4/008006 +- caax_a549_mantis_2026_03_26_train/B/4/008008 +test_fovs: +- membrane_hipsc_test/4/11393/1428 +- membrane_hipsc_test/4/11479/1481 +- membrane_hipsc_test/4/18007/1641 +- membrane_hipsc_test/4/18102/1710 +- membrane_hipsc_test/4/18485/1842 +- membrane_hipsc_test/4/22901/3306 +- membrane_hipsc_test/4/27797/2857 +- membrane_hipsc_test/4/28759/3400 +- membrane_hipsc_test/4/29060/3786 +- membrane_hipsc_test/4/29140/3687 +- membrane_hipsc_test/4/29334/3890 +- membrane_hipsc_test/4/30293/3915 +- membrane_hipsc_test/4/31736/15232 +- membrane_hipsc_test/4/32024/4089 +- membrane_hipsc_test/4/34998/4271 +- membrane_hipsc_test/4/35284/4501 +- membrane_hipsc_test/4/36643/4930 +- membrane_hipsc_test/4/37601/5175 +- membrane_hipsc_test/4/38464/5176 +- membrane_hipsc_test/4/4556/15828 +- membrane_hipsc_test/4/4556/16242 +- membrane_hipsc_test/4/5910/824 +- membrane_hipsc_test/4/6497/1014 +- membrane_hipsc_test/4/6775/1242 +- membrane_hipsc_test/4/8706/1138 +- membrane_hipsc_test/4/94507/699 +- membrane_hipsc_test/41/44212/5751 +- membrane_hipsc_test/41/48436/5515 +- membrane_hipsc_test/41/48536/5593 +- membrane_hipsc_test/41/49121/5716 +- membrane_hipsc_test/41/49121/5777 +- membrane_hipsc_test/41/49204/5680 +- membrane_hipsc_test/41/49888/5888 +- membrane_hipsc_test/41/49975/5926 +- membrane_hipsc_test/41/50548/6016 +- membrane_hipsc_test/41/52564/5966 +- membrane_hipsc_test/41/53048/15203 +- membrane_hipsc_test/41/55160/6367 +- membrane_hipsc_test/41/55348/6437 +- membrane_hipsc_test/41/55350/6427 +- membrane_hipsc_test/41/58326/6874 +- membrane_hipsc_test/41/58517/6781 +- membrane_hipsc_test/41/60728/7413 +- membrane_hipsc_test/41/62754/7076 +- membrane_hipsc_test/41/63524/7359 +- membrane_hipsc_test/41/63524/7400 +- membrane_hipsc_test/41/63713/7287 +- membrane_hipsc_test/41/66020/7541 +- membrane_hipsc_test/41/67168/7688 +- membrane_hipsc_test/41/68116/7831 +- membrane_hipsc_test/41/68598/9132 +- membrane_hipsc_test/41/68804/8999 +- membrane_hipsc_test/41/68884/9247 +- membrane_hipsc_test/41/68885/9316 +- membrane_hipsc_test/41/70240/9487 +- membrane_hipsc_test/41/72356/7974 +- membrane_hipsc_test/41/72629/8071 +- membrane_hipsc_test/41/72725/8138 +- membrane_hipsc_test/41/72727/8125 +- membrane_hipsc_test/41/73112/8476 +- membrane_hipsc_test/41/73304/8259 +- membrane_hipsc_test/41/73686/8660 +- membrane_hipsc_test/41/73686/8668 +- membrane_hipsc_test/41/73783/8567 +- membrane_hipsc_test/41/74264/8751 +- membrane_hipsc_test/41/74272/8740 +- membrane_hipsc_test/41/74356/8919 +- membrane_hipsc_test/41/75800/8019 +- membrane_hipsc_test/41/75808/7975 +- membrane_hipsc_test/42/107478/10817 +- membrane_hipsc_test/42/114584/12053 +- membrane_hipsc_test/42/115556/15421 +- membrane_hipsc_test/42/116598/10604 +- membrane_hipsc_test/42/117557/11343 +- membrane_hipsc_test/42/118901/11674 +- membrane_hipsc_test/42/118912/11694 +- membrane_hipsc_test/42/123916/16655 +- membrane_hipsc_test/42/124001/16229 +- membrane_hipsc_test/42/127171/12338 +- membrane_hipsc_test/42/127276/23725 +- membrane_hipsc_test/42/127939/12482 +- membrane_hipsc_test/42/128428/12536 +- membrane_hipsc_test/42/128523/12637 +- membrane_hipsc_test/42/129665/12780 +- membrane_hipsc_test/42/129855/12890 +- membrane_hipsc_test/42/132463/13304 +- membrane_hipsc_test/42/132834/13446 +- membrane_hipsc_test/42/133599/13746 +- membrane_hipsc_test/42/135439/14132 +- membrane_hipsc_test/42/137449/14744 +- membrane_hipsc_test/42/137455/14731 +- membrane_hipsc_test/42/137460/14685 +- membrane_hipsc_test/42/137582/14642 +- membrane_hipsc_test/42/137774/14522 +- membrane_hipsc_test/42/137820/14488 +- membrane_hipsc_test/42/137953/15518 +- membrane_hipsc_test/42/77924/9512 +- membrane_hipsc_test/42/80023/9994 +- membrane_hipsc_test/42/82708/16181 +- membrane_hipsc_test/42/84449/15422 +- caax_a549_mantis_2026_03_26_test/B/2/000001 +- caax_a549_mantis_2026_03_26_test/B/2/000004 +- caax_a549_mantis_2026_03_26_test/B/2/000007 +- caax_a549_mantis_2026_03_26_test/B/2/003001 +- caax_a549_mantis_2026_03_26_test/B/2/003004 +- caax_a549_mantis_2026_03_26_test/B/2/003007 +- caax_a549_mantis_2026_03_26_test/B/2/005001 +- caax_a549_mantis_2026_03_26_test/B/2/005004 +- caax_a549_mantis_2026_03_26_test/B/2/005007 +- caax_a549_mantis_2026_03_26_test/B/2/008001 +- caax_a549_mantis_2026_03_26_test/B/2/008004 +- caax_a549_mantis_2026_03_26_test/B/2/008007 +- caax_a549_mantis_2026_03_26_test/B/3/000001 +- caax_a549_mantis_2026_03_26_test/B/3/000004 +- caax_a549_mantis_2026_03_26_test/B/3/000007 +- caax_a549_mantis_2026_03_26_test/B/3/003001 +- caax_a549_mantis_2026_03_26_test/B/3/003004 +- caax_a549_mantis_2026_03_26_test/B/3/003007 +- caax_a549_mantis_2026_03_26_test/B/3/005001 +- caax_a549_mantis_2026_03_26_test/B/3/005004 +- caax_a549_mantis_2026_03_26_test/B/3/005007 +- caax_a549_mantis_2026_03_26_test/B/3/008001 +- caax_a549_mantis_2026_03_26_test/B/3/008004 +- caax_a549_mantis_2026_03_26_test/B/3/008007 +- caax_a549_mantis_2026_03_26_test/B/4/000001 +- caax_a549_mantis_2026_03_26_test/B/4/000004 +- caax_a549_mantis_2026_03_26_test/B/4/000007 +- caax_a549_mantis_2026_03_26_test/B/4/003001 +- caax_a549_mantis_2026_03_26_test/B/4/003004 +- caax_a549_mantis_2026_03_26_test/B/4/003007 +- caax_a549_mantis_2026_03_26_test/B/4/005001 +- caax_a549_mantis_2026_03_26_test/B/4/005004 +- caax_a549_mantis_2026_03_26_test/B/4/005007 +- caax_a549_mantis_2026_03_26_test/B/4/008001 +- caax_a549_mantis_2026_03_26_test/B/4/008004 +- caax_a549_mantis_2026_03_26_test/B/4/008007 diff --git a/applications/dynacell/configs/collections/virtual_staining/membrane_joint_mock_v1.yaml b/applications/dynacell/configs/collections/virtual_staining/membrane_joint_mock_v1.yaml new file mode 100644 index 000000000..286c64ed4 --- /dev/null +++ b/applications/dynacell/configs/collections/virtual_staining/membrane_joint_mock_v1.yaml @@ -0,0 +1,779 @@ +name: membrane_joint_mock_v1 +description: Joint frozen benchmark collection with condition filter 'mock' across + 2 selectors covering targets 'caax', 'membrane'. Channels and FOV membership captured + from the live train/test zarr stores at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-27T12:04:03.085047+00:00' + created_by: Alex Kalinin +experiments: +- name: membrane_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Membrane + organelle: membrane + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: membrane_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Membrane + organelle: membrane + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: caax_a549_mantis_2026_03_26_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2026_03_26_A549_CAAX_H2B_DENV_ZIKV/train/CAAX.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Membrane + marker: CAAX + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: CAAX + organelle: membrane + pixel_size_xy_um: 0.116 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: caax_a549_mantis_2026_03_26_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2026_03_26_A549_CAAX_H2B_DENV_ZIKV/test/CAAX.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Membrane + marker: CAAX + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: CAAX + organelle: membrane + pixel_size_xy_um: 0.116 + pixel_size_z_um: 0.174 + exclude_fovs: [] +train_fovs: +- membrane_hipsc_train/4/10615/1304 +- membrane_hipsc_train/4/10625/1347 +- membrane_hipsc_train/4/10900/1427 +- membrane_hipsc_train/4/10904/1436 +- membrane_hipsc_train/4/11384/1404 +- membrane_hipsc_train/4/11478/1468 +- membrane_hipsc_train/4/11490/1466 +- membrane_hipsc_train/4/11492/1467 +- membrane_hipsc_train/4/11573/1414 +- membrane_hipsc_train/4/136707/16750 +- membrane_hipsc_train/4/136710/15363 +- membrane_hipsc_train/4/136721/16107 +- membrane_hipsc_train/4/136725/15834 +- membrane_hipsc_train/4/13974/1528 +- membrane_hipsc_train/4/14646/1871 +- membrane_hipsc_train/4/14740/1745 +- membrane_hipsc_train/4/14742/1791 +- membrane_hipsc_train/4/14754/1781 +- membrane_hipsc_train/4/1493/268 +- membrane_hipsc_train/4/1508/255 +- membrane_hipsc_train/4/16278/2186 +- membrane_hipsc_train/4/16376/2374 +- membrane_hipsc_train/4/16468/2321 +- membrane_hipsc_train/4/16469/2337 +- membrane_hipsc_train/4/16469/2339 +- membrane_hipsc_train/4/16469/2345 +- membrane_hipsc_train/4/16471/2265 +- membrane_hipsc_train/4/16472/2312 +- membrane_hipsc_train/4/16951/2459 +- membrane_hipsc_train/4/16951/2480 +- membrane_hipsc_train/4/16952/2494 +- membrane_hipsc_train/4/17333/2710 +- membrane_hipsc_train/4/17348/16148 +- membrane_hipsc_train/4/17525/2811 +- membrane_hipsc_train/4/17526/2752 +- membrane_hipsc_train/4/17536/2773 +- membrane_hipsc_train/4/18020/1618 +- membrane_hipsc_train/4/18020/1625 +- membrane_hipsc_train/4/18020/1638 +- membrane_hipsc_train/4/18487/1811 +- membrane_hipsc_train/4/19351/1905 +- membrane_hipsc_train/4/19543/2105 +- membrane_hipsc_train/4/19554/2020 +- membrane_hipsc_train/4/19556/2089 +- membrane_hipsc_train/4/20416/2223 +- membrane_hipsc_train/4/20596/2406 +- membrane_hipsc_train/4/20597/2395 +- membrane_hipsc_train/4/20597/2401 +- membrane_hipsc_train/4/20599/2373 +- membrane_hipsc_train/4/21077/2254 +- membrane_hipsc_train/4/21089/2293 +- membrane_hipsc_train/4/21556/2491 +- membrane_hipsc_train/4/21557/2483 +- membrane_hipsc_train/4/21557/2527 +- membrane_hipsc_train/4/21653/2547 +- membrane_hipsc_train/4/21860/15671 +- membrane_hipsc_train/4/21940/2736 +- membrane_hipsc_train/4/21943/2717 +- membrane_hipsc_train/4/21953/2739 +- membrane_hipsc_train/4/22133/2826 +- membrane_hipsc_train/4/22136/2827 +- membrane_hipsc_train/4/22339/3095 +- membrane_hipsc_train/4/22340/3097 +- membrane_hipsc_train/4/22612/2915 +- membrane_hipsc_train/4/22614/2923 +- membrane_hipsc_train/4/22615/2978 +- membrane_hipsc_train/4/22624/2909 +- membrane_hipsc_train/4/22709/3070 +- membrane_hipsc_train/4/22712/3090 +- membrane_hipsc_train/4/22913/3301 +- membrane_hipsc_train/4/22914/3289 +- membrane_hipsc_train/4/23380/3237 +- membrane_hipsc_train/4/23392/3212 +- membrane_hipsc_train/4/23395/3223 +- membrane_hipsc_train/4/23574/3492 +- membrane_hipsc_train/4/23764/3409 +- membrane_hipsc_train/4/24152/3567 +- membrane_hipsc_train/4/24724/3661 +- membrane_hipsc_train/4/24727/3659 +- membrane_hipsc_train/4/24928/3585 +- membrane_hipsc_train/4/25784/3851 +- membrane_hipsc_train/4/27800/2883 +- membrane_hipsc_train/4/27896/2943 +- membrane_hipsc_train/4/27992/3020 +- membrane_hipsc_train/4/28084/3214 +- membrane_hipsc_train/4/28084/3270 +- membrane_hipsc_train/4/28087/3266 +- membrane_hipsc_train/4/28756/3381 +- membrane_hipsc_train/4/28759/3393 +- membrane_hipsc_train/4/29045/3764 +- membrane_hipsc_train/4/29060/3753 +- membrane_hipsc_train/4/29143/3667 +- membrane_hipsc_train/4/29155/3710 +- membrane_hipsc_train/4/2932/230 +- membrane_hipsc_train/4/29333/3908 +- membrane_hipsc_train/4/2945/173 +- membrane_hipsc_train/4/30292/14379 +- membrane_hipsc_train/4/30293/3905 +- membrane_hipsc_train/4/30308/3869 +- membrane_hipsc_train/4/30388/16862 +- membrane_hipsc_train/4/30389/15342 +- membrane_hipsc_train/4/30392/16741 +- membrane_hipsc_train/4/31732/17059 +- membrane_hipsc_train/4/31744/16779 +- membrane_hipsc_train/4/31841/3962 +- membrane_hipsc_train/4/31939/3975 +- membrane_hipsc_train/4/32024/4077 +- membrane_hipsc_train/4/32033/4111 +- membrane_hipsc_train/4/32033/4121 +- membrane_hipsc_train/4/32035/4099 +- membrane_hipsc_train/4/33077/4379 +- membrane_hipsc_train/4/33572/4229 +- membrane_hipsc_train/4/33942/15337 +- membrane_hipsc_train/4/33942/16205 +- membrane_hipsc_train/4/33943/17061 +- membrane_hipsc_train/4/33953/16561 +- membrane_hipsc_train/4/33955/16023 +- membrane_hipsc_train/4/34038/4363 +- membrane_hipsc_train/4/34808/4417 +- membrane_hipsc_train/4/35000/4274 +- membrane_hipsc_train/4/35284/4472 +- membrane_hipsc_train/4/35287/4460 +- membrane_hipsc_train/4/35479/4551 +- membrane_hipsc_train/4/35489/4583 +- membrane_hipsc_train/4/36449/15327 +- membrane_hipsc_train/4/36544/4909 +- membrane_hipsc_train/4/36544/4931 +- membrane_hipsc_train/4/36628/4907 +- membrane_hipsc_train/4/36836/4996 +- membrane_hipsc_train/4/37591/5133 +- membrane_hipsc_train/4/37603/5147 +- membrane_hipsc_train/4/37972/5388 +- membrane_hipsc_train/4/37988/5373 +- membrane_hipsc_train/4/40084/5359 +- membrane_hipsc_train/4/40086/5362 +- membrane_hipsc_train/4/40376/4584 +- membrane_hipsc_train/4/40385/4614 +- membrane_hipsc_train/4/40386/4613 +- membrane_hipsc_train/4/40387/4586 +- membrane_hipsc_train/4/40483/4619 +- membrane_hipsc_train/4/40483/4621 +- membrane_hipsc_train/4/40960/4654 +- membrane_hipsc_train/4/41044/4851 +- membrane_hipsc_train/4/41047/4885 +- membrane_hipsc_train/4/41237/4861 +- membrane_hipsc_train/4/41249/4835 +- membrane_hipsc_train/4/41912/5074 +- membrane_hipsc_train/4/5143/954 +- membrane_hipsc_train/4/5236/869 +- membrane_hipsc_train/4/5238/875 +- membrane_hipsc_train/4/6485/1018 +- membrane_hipsc_train/4/6486/992 +- membrane_hipsc_train/4/6497/1003 +- membrane_hipsc_train/4/6775/1203 +- membrane_hipsc_train/4/6775/1226 +- membrane_hipsc_train/4/6775/1236 +- membrane_hipsc_train/4/7156/1124 +- membrane_hipsc_train/4/7349/1355 +- membrane_hipsc_train/4/7650/1278 +- membrane_hipsc_train/4/8214/878 +- membrane_hipsc_train/4/8214/879 +- membrane_hipsc_train/4/8228/898 +- membrane_hipsc_train/4/8695/1215 +- membrane_hipsc_train/4/88267/15294 +- membrane_hipsc_train/4/89048/356 +- membrane_hipsc_train/4/8982/1171 +- membrane_hipsc_train/4/90088/415 +- membrane_hipsc_train/4/90858/15658 +- membrane_hipsc_train/4/90858/16534 +- membrane_hipsc_train/4/91144/102 +- membrane_hipsc_train/4/91924/458 +- membrane_hipsc_train/4/93448/596 +- membrane_hipsc_train/4/94312/684 +- membrane_hipsc_train/4/95752/811 +- membrane_hipsc_train/4/95753/737 +- membrane_hipsc_train/4/95753/872 +- membrane_hipsc_train/41/43638/5246 +- membrane_hipsc_train/41/43639/5265 +- membrane_hipsc_train/41/43732/16519 +- membrane_hipsc_train/41/45556/5706 +- membrane_hipsc_train/41/45556/5734 +- membrane_hipsc_train/41/45559/5714 +- membrane_hipsc_train/41/48436/5507 +- membrane_hipsc_train/41/48534/5575 +- membrane_hipsc_train/41/48535/5623 +- membrane_hipsc_train/41/48548/5574 +- membrane_hipsc_train/41/48548/5589 +- membrane_hipsc_train/41/49204/5661 +- membrane_hipsc_train/41/49220/5671 +- membrane_hipsc_train/41/49698/5819 +- membrane_hipsc_train/41/49972/5933 +- membrane_hipsc_train/41/49973/5960 +- membrane_hipsc_train/41/50263/6077 +- membrane_hipsc_train/41/50263/6082 +- membrane_hipsc_train/41/50356/15510 +- membrane_hipsc_train/41/50356/15578 +- membrane_hipsc_train/41/50359/15457 +- membrane_hipsc_train/41/50548/6024 +- membrane_hipsc_train/41/50551/6022 +- membrane_hipsc_train/41/53044/15243 +- membrane_hipsc_train/41/53046/16965 +- membrane_hipsc_train/41/53428/6238 +- membrane_hipsc_train/41/53524/15636 +- membrane_hipsc_train/41/53538/15395 +- membrane_hipsc_train/41/53731/15920 +- membrane_hipsc_train/41/55156/6355 +- membrane_hipsc_train/41/55156/6358 +- membrane_hipsc_train/41/55158/6324 +- membrane_hipsc_train/41/55158/6353 +- membrane_hipsc_train/41/55253/6499 +- membrane_hipsc_train/41/55256/6482 +- membrane_hipsc_train/41/55351/6419 +- membrane_hipsc_train/41/55363/6362 +- membrane_hipsc_train/41/55925/6584 +- membrane_hipsc_train/41/56406/6643 +- membrane_hipsc_train/41/56416/6614 +- membrane_hipsc_train/41/56418/6626 +- membrane_hipsc_train/41/56419/6630 +- membrane_hipsc_train/41/56596/6678 +- membrane_hipsc_train/41/56896/7720 +- membrane_hipsc_train/41/57364/6456 +- membrane_hipsc_train/41/57365/6428 +- membrane_hipsc_train/41/57367/6430 +- membrane_hipsc_train/41/57464/6544 +- membrane_hipsc_train/41/57472/6556 +- membrane_hipsc_train/41/57472/6565 +- membrane_hipsc_train/41/58134/6821 +- membrane_hipsc_train/41/58326/6840 +- membrane_hipsc_train/41/58420/6971 +- membrane_hipsc_train/41/58423/6963 +- membrane_hipsc_train/41/58518/6786 +- membrane_hipsc_train/41/59285/7118 +- membrane_hipsc_train/41/59285/7124 +- membrane_hipsc_train/41/59298/7175 +- membrane_hipsc_train/41/59380/7015 +- membrane_hipsc_train/41/59479/7188 +- membrane_hipsc_train/41/59479/7200 +- membrane_hipsc_train/41/59480/7179 +- membrane_hipsc_train/41/60548/7475 +- membrane_hipsc_train/41/60632/7345 +- membrane_hipsc_train/41/60726/7399 +- membrane_hipsc_train/41/60737/7332 +- membrane_hipsc_train/41/60738/7414 +- membrane_hipsc_train/41/62740/7068 +- membrane_hipsc_train/41/62932/6916 +- membrane_hipsc_train/41/63508/7389 +- membrane_hipsc_train/41/63523/7383 +- membrane_hipsc_train/41/63608/7462 +- membrane_hipsc_train/41/63608/7464 +- membrane_hipsc_train/41/63620/7451 +- membrane_hipsc_train/41/63701/7283 +- membrane_hipsc_train/41/63713/7256 +- membrane_hipsc_train/41/66292/7775 +- membrane_hipsc_train/41/66292/7782 +- membrane_hipsc_train/41/66292/7796 +- membrane_hipsc_train/41/66296/7788 +- membrane_hipsc_train/41/67157/7690 +- membrane_hipsc_train/41/67168/7678 +- membrane_hipsc_train/41/68131/7834 +- membrane_hipsc_train/41/68503/9206 +- membrane_hipsc_train/41/68504/9176 +- membrane_hipsc_train/41/68504/9197 +- membrane_hipsc_train/41/68512/9188 +- membrane_hipsc_train/41/68512/9207 +- membrane_hipsc_train/41/68512/9212 +- membrane_hipsc_train/41/68708/9065 +- membrane_hipsc_train/41/68788/9030 +- membrane_hipsc_train/41/68800/9019 +- membrane_hipsc_train/41/69472/9285 +- membrane_hipsc_train/41/69473/9279 +- membrane_hipsc_train/41/69474/9306 +- membrane_hipsc_train/41/70052/15689 +- membrane_hipsc_train/41/70231/9525 +- membrane_hipsc_train/41/70232/9551 +- membrane_hipsc_train/41/72244/8037 +- membrane_hipsc_train/41/72244/8074 +- membrane_hipsc_train/41/72256/8049 +- membrane_hipsc_train/41/72260/8085 +- membrane_hipsc_train/41/72342/7994 +- membrane_hipsc_train/41/72356/7962 +- membrane_hipsc_train/41/72628/8109 +- membrane_hipsc_train/41/72629/8086 +- membrane_hipsc_train/41/72630/8119 +- membrane_hipsc_train/41/72631/8095 +- membrane_hipsc_train/41/72725/8151 +- membrane_hipsc_train/41/72726/8128 +- membrane_hipsc_train/41/72834/8288 +- membrane_hipsc_train/41/73300/8255 +- membrane_hipsc_train/41/73396/8265 +- membrane_hipsc_train/41/73397/8271 +- membrane_hipsc_train/41/73398/8307 +- membrane_hipsc_train/41/73495/8186 +- membrane_hipsc_train/41/73507/8203 +- membrane_hipsc_train/41/73685/8634 +- membrane_hipsc_train/41/73687/8628 +- membrane_hipsc_train/41/73700/8663 +- membrane_hipsc_train/41/73782/8525 +- membrane_hipsc_train/41/73782/8576 +- membrane_hipsc_train/41/73783/8530 +- membrane_hipsc_train/41/73784/8543 +- membrane_hipsc_train/41/73879/15995 +- membrane_hipsc_train/41/73975/15832 +- membrane_hipsc_train/41/74165/8821 +- membrane_hipsc_train/41/74168/8793 +- membrane_hipsc_train/41/74260/8727 +- membrane_hipsc_train/41/74273/8721 +- membrane_hipsc_train/41/74371/8941 +- membrane_hipsc_train/41/74371/8978 +- membrane_hipsc_train/41/75042/7915 +- membrane_hipsc_train/41/75124/16978 +- membrane_hipsc_train/41/75125/16693 +- membrane_hipsc_train/41/75512/7872 +- membrane_hipsc_train/41/75796/7941 +- membrane_hipsc_train/41/75799/7953 +- membrane_hipsc_train/41/76000/8244 +- membrane_hipsc_train/41/77250/8868 +- membrane_hipsc_train/41/77333/9094 +- membrane_hipsc_train/42/106420/10373 +- membrane_hipsc_train/42/106421/10380 +- membrane_hipsc_train/42/106422/10368 +- membrane_hipsc_train/42/106516/10272 +- membrane_hipsc_train/42/106518/10239 +- membrane_hipsc_train/42/106520/10262 +- membrane_hipsc_train/42/106915/10747 +- membrane_hipsc_train/42/106996/10652 +- membrane_hipsc_train/42/106998/10641 +- membrane_hipsc_train/42/107480/10815 +- membrane_hipsc_train/42/107480/10822 +- membrane_hipsc_train/42/107572/12022 +- membrane_hipsc_train/42/107574/11982 +- membrane_hipsc_train/42/107574/12039 +- membrane_hipsc_train/42/107682/11895 +- membrane_hipsc_train/42/107682/11898 +- membrane_hipsc_train/42/107684/11928 +- membrane_hipsc_train/42/107956/11969 +- membrane_hipsc_train/42/107956/11981 +- membrane_hipsc_train/42/107958/11911 +- membrane_hipsc_train/42/107959/12029 +- membrane_hipsc_train/42/107972/11941 +- membrane_hipsc_train/42/108148/15673 +- membrane_hipsc_train/42/108149/12190 +- membrane_hipsc_train/42/108246/11135 +- membrane_hipsc_train/42/108248/16355 +- membrane_hipsc_train/42/108824/15581 +- membrane_hipsc_train/42/108833/15155 +- membrane_hipsc_train/42/110548/10130 +- membrane_hipsc_train/42/110552/10154 +- membrane_hipsc_train/42/110552/10175 +- membrane_hipsc_train/42/110645/10108 +- membrane_hipsc_train/42/110646/10124 +- membrane_hipsc_train/42/110660/10091 +- membrane_hipsc_train/42/110947/10199 +- membrane_hipsc_train/42/111125/10242 +- membrane_hipsc_train/42/111413/10485 +- membrane_hipsc_train/42/111415/10486 +- membrane_hipsc_train/42/111426/10473 +- membrane_hipsc_train/42/111892/10724 +- membrane_hipsc_train/42/112084/15061 +- membrane_hipsc_train/42/112085/16293 +- membrane_hipsc_train/42/112280/15454 +- membrane_hipsc_train/42/112565/10904 +- membrane_hipsc_train/42/112758/16064 +- membrane_hipsc_train/42/112772/14973 +- membrane_hipsc_train/42/113432/11852 +- membrane_hipsc_train/42/113634/10939 +- membrane_hipsc_train/42/113921/11053 +- membrane_hipsc_train/42/114209/10977 +- membrane_hipsc_train/42/114212/10981 +- membrane_hipsc_train/42/114787/11121 +- membrane_hipsc_train/42/114788/11097 +- membrane_hipsc_train/42/114965/11232 +- membrane_hipsc_train/42/114965/11269 +- membrane_hipsc_train/42/114979/11222 +- membrane_hipsc_train/42/115160/12126 +- membrane_hipsc_train/42/115169/16617 +- membrane_hipsc_train/42/115349/11410 +- membrane_hipsc_train/42/115541/15346 +- membrane_hipsc_train/42/115542/16879 +- membrane_hipsc_train/42/115552/15185 +- membrane_hipsc_train/42/115554/15716 +- membrane_hipsc_train/42/115555/16425 +- membrane_hipsc_train/42/115556/15703 +- membrane_hipsc_train/42/115831/11479 +- membrane_hipsc_train/42/116034/11497 +- membrane_hipsc_train/42/116309/11595 +- membrane_hipsc_train/42/116324/11616 +- membrane_hipsc_train/42/116608/10515 +- membrane_hipsc_train/42/116608/10614 +- membrane_hipsc_train/42/116887/10440 +- membrane_hipsc_train/42/116897/10412 +- membrane_hipsc_train/42/116900/10422 +- membrane_hipsc_train/42/117173/10673 +- membrane_hipsc_train/42/117186/10657 +- membrane_hipsc_train/42/117557/11347 +- membrane_hipsc_train/42/117559/11367 +- membrane_hipsc_train/42/117572/11385 +- membrane_hipsc_train/42/117847/11299 +- membrane_hipsc_train/42/118420/11731 +- membrane_hipsc_train/42/118423/11658 +- membrane_hipsc_train/42/118712/11569 +- membrane_hipsc_train/42/118806/11804 +- membrane_hipsc_train/42/118808/11800 +- membrane_hipsc_train/42/121791/16666 +- membrane_hipsc_train/42/121793/15852 +- membrane_hipsc_train/42/121806/15946 +- membrane_hipsc_train/42/123328/15550 +- membrane_hipsc_train/42/123328/17092 +- membrane_hipsc_train/42/123714/16851 +- membrane_hipsc_train/42/123903/15431 +- membrane_hipsc_train/42/124002/16132 +- membrane_hipsc_train/42/124014/16885 +- membrane_hipsc_train/42/124205/15565 +- membrane_hipsc_train/42/124287/15382 +- membrane_hipsc_train/42/124290/15483 +- membrane_hipsc_train/42/124291/15731 +- membrane_hipsc_train/42/124299/16712 +- membrane_hipsc_train/42/124301/15843 +- membrane_hipsc_train/42/127171/12333 +- membrane_hipsc_train/42/127647/12252 +- membrane_hipsc_train/42/127648/12223 +- membrane_hipsc_train/42/127649/12208 +- membrane_hipsc_train/42/127650/12238 +- membrane_hipsc_train/42/127650/12256 +- membrane_hipsc_train/42/127651/12217 +- membrane_hipsc_train/42/127651/12239 +- membrane_hipsc_train/42/127852/12320 +- membrane_hipsc_train/42/127935/12457 +- membrane_hipsc_train/42/127947/12485 +- membrane_hipsc_train/42/128416/12512 +- membrane_hipsc_train/42/128514/12657 +- membrane_hipsc_train/42/128514/12667 +- membrane_hipsc_train/42/128525/12654 +- membrane_hipsc_train/42/128715/12598 +- membrane_hipsc_train/42/128718/12626 +- membrane_hipsc_train/42/128719/12625 +- membrane_hipsc_train/42/129473/12830 +- membrane_hipsc_train/42/129473/12852 +- membrane_hipsc_train/42/129571/12811 +- membrane_hipsc_train/42/129583/12802 +- membrane_hipsc_train/42/129774/12715 +- membrane_hipsc_train/42/129855/12931 +- membrane_hipsc_train/42/130155/13043 +- membrane_hipsc_train/42/130527/12960 +- membrane_hipsc_train/42/130625/16186 +- membrane_hipsc_train/42/130707/13231 +- membrane_hipsc_train/42/130722/17097 +- membrane_hipsc_train/42/132173/13409 +- membrane_hipsc_train/42/132175/13365 +- membrane_hipsc_train/42/132653/13278 +- membrane_hipsc_train/42/132831/13415 +- membrane_hipsc_train/42/132844/13432 +- membrane_hipsc_train/42/132845/13448 +- membrane_hipsc_train/42/132929/13513 +- membrane_hipsc_train/42/133133/13640 +- membrane_hipsc_train/42/133323/13465 +- membrane_hipsc_train/42/133324/13457 +- membrane_hipsc_train/42/133325/13497 +- membrane_hipsc_train/42/133503/13577 +- membrane_hipsc_train/42/133504/13572 +- membrane_hipsc_train/42/133602/13711 +- membrane_hipsc_train/42/133711/13788 +- membrane_hipsc_train/42/134272/13918 +- membrane_hipsc_train/42/134286/13916 +- membrane_hipsc_train/42/134656/13884 +- membrane_hipsc_train/42/135272/14059 +- membrane_hipsc_train/42/135440/14128 +- membrane_hipsc_train/42/135525/14245 +- membrane_hipsc_train/42/135614/14178 +- membrane_hipsc_train/42/137434/14771 +- membrane_hipsc_train/42/137464/14708 +- membrane_hipsc_train/42/137767/14413 +- membrane_hipsc_train/42/137772/14516 +- membrane_hipsc_train/42/137956/15501 +- membrane_hipsc_train/42/137956/16613 +- membrane_hipsc_train/42/137956/17196 +- membrane_hipsc_train/42/137956/17224 +- membrane_hipsc_train/42/138024/15890 +- membrane_hipsc_train/42/138028/16174 +- membrane_hipsc_train/42/138032/15577 +- membrane_hipsc_train/42/138261/16083 +- membrane_hipsc_train/42/77912/9479 +- membrane_hipsc_train/42/77912/9520 +- membrane_hipsc_train/42/77923/9543 +- membrane_hipsc_train/42/78389/9675 +- membrane_hipsc_train/42/78391/9672 +- membrane_hipsc_train/42/78487/9750 +- membrane_hipsc_train/42/78487/9758 +- membrane_hipsc_train/42/78691/9802 +- membrane_hipsc_train/42/79541/9897 +- membrane_hipsc_train/42/79552/9894 +- membrane_hipsc_train/42/79554/9874 +- membrane_hipsc_train/42/79828/9972 +- membrane_hipsc_train/42/79831/9969 +- membrane_hipsc_train/42/79832/9978 +- membrane_hipsc_train/42/79841/9963 +- membrane_hipsc_train/42/80023/15006 +- membrane_hipsc_train/42/80033/15189 +- membrane_hipsc_train/42/80035/9980 +- membrane_hipsc_train/42/80224/9960 +- membrane_hipsc_train/42/83392/9630 +- caax_a549_mantis_2026_03_26_train/B/2/000002 +- caax_a549_mantis_2026_03_26_train/B/2/000003 +- caax_a549_mantis_2026_03_26_train/B/2/000005 +- caax_a549_mantis_2026_03_26_train/B/2/000006 +- caax_a549_mantis_2026_03_26_train/B/2/000008 +- caax_a549_mantis_2026_03_26_train/B/2/001000 +- caax_a549_mantis_2026_03_26_train/B/2/001001 +- caax_a549_mantis_2026_03_26_train/B/2/001002 +- caax_a549_mantis_2026_03_26_train/B/2/001003 +- caax_a549_mantis_2026_03_26_train/B/2/001004 +- caax_a549_mantis_2026_03_26_train/B/2/001005 +- caax_a549_mantis_2026_03_26_train/B/2/001006 +- caax_a549_mantis_2026_03_26_train/B/2/001007 +- caax_a549_mantis_2026_03_26_train/B/2/001008 +- caax_a549_mantis_2026_03_26_train/B/2/002000 +- caax_a549_mantis_2026_03_26_train/B/2/002001 +- caax_a549_mantis_2026_03_26_train/B/2/002002 +- caax_a549_mantis_2026_03_26_train/B/2/002003 +- caax_a549_mantis_2026_03_26_train/B/2/002004 +- caax_a549_mantis_2026_03_26_train/B/2/002005 +- caax_a549_mantis_2026_03_26_train/B/2/002006 +- caax_a549_mantis_2026_03_26_train/B/2/002007 +- caax_a549_mantis_2026_03_26_train/B/2/002008 +- caax_a549_mantis_2026_03_26_train/B/2/003000 +- caax_a549_mantis_2026_03_26_train/B/2/003002 +- caax_a549_mantis_2026_03_26_train/B/2/003003 +- caax_a549_mantis_2026_03_26_train/B/2/003005 +- caax_a549_mantis_2026_03_26_train/B/2/003006 +- caax_a549_mantis_2026_03_26_train/B/2/003008 +- caax_a549_mantis_2026_03_26_train/B/2/004000 +- caax_a549_mantis_2026_03_26_train/B/2/004001 +- caax_a549_mantis_2026_03_26_train/B/2/004002 +- caax_a549_mantis_2026_03_26_train/B/2/004003 +- caax_a549_mantis_2026_03_26_train/B/2/004004 +- caax_a549_mantis_2026_03_26_train/B/2/004005 +- caax_a549_mantis_2026_03_26_train/B/2/004006 +- caax_a549_mantis_2026_03_26_train/B/2/004007 +- caax_a549_mantis_2026_03_26_train/B/2/004008 +- caax_a549_mantis_2026_03_26_train/B/2/005000 +- caax_a549_mantis_2026_03_26_train/B/2/005002 +- caax_a549_mantis_2026_03_26_train/B/2/005003 +- caax_a549_mantis_2026_03_26_train/B/2/005005 +- caax_a549_mantis_2026_03_26_train/B/2/005006 +- caax_a549_mantis_2026_03_26_train/B/2/005008 +- caax_a549_mantis_2026_03_26_train/B/2/006000 +- caax_a549_mantis_2026_03_26_train/B/2/006001 +- caax_a549_mantis_2026_03_26_train/B/2/006002 +- caax_a549_mantis_2026_03_26_train/B/2/006003 +- caax_a549_mantis_2026_03_26_train/B/2/006004 +- caax_a549_mantis_2026_03_26_train/B/2/006005 +- caax_a549_mantis_2026_03_26_train/B/2/006006 +- caax_a549_mantis_2026_03_26_train/B/2/006007 +- caax_a549_mantis_2026_03_26_train/B/2/006008 +- caax_a549_mantis_2026_03_26_train/B/2/007000 +- caax_a549_mantis_2026_03_26_train/B/2/007001 +- caax_a549_mantis_2026_03_26_train/B/2/007002 +- caax_a549_mantis_2026_03_26_train/B/2/007003 +- caax_a549_mantis_2026_03_26_train/B/2/007004 +- caax_a549_mantis_2026_03_26_train/B/2/007005 +- caax_a549_mantis_2026_03_26_train/B/2/007006 +- caax_a549_mantis_2026_03_26_train/B/2/007007 +- caax_a549_mantis_2026_03_26_train/B/2/007008 +- caax_a549_mantis_2026_03_26_train/B/2/008000 +- caax_a549_mantis_2026_03_26_train/B/2/008002 +- caax_a549_mantis_2026_03_26_train/B/2/008003 +- caax_a549_mantis_2026_03_26_train/B/2/008005 +- caax_a549_mantis_2026_03_26_train/B/2/008006 +- caax_a549_mantis_2026_03_26_train/B/2/008008 +test_fovs: +- membrane_hipsc_test/4/11393/1428 +- membrane_hipsc_test/4/11479/1481 +- membrane_hipsc_test/4/18007/1641 +- membrane_hipsc_test/4/18102/1710 +- membrane_hipsc_test/4/18485/1842 +- membrane_hipsc_test/4/22901/3306 +- membrane_hipsc_test/4/27797/2857 +- membrane_hipsc_test/4/28759/3400 +- membrane_hipsc_test/4/29060/3786 +- membrane_hipsc_test/4/29140/3687 +- membrane_hipsc_test/4/29334/3890 +- membrane_hipsc_test/4/30293/3915 +- membrane_hipsc_test/4/31736/15232 +- membrane_hipsc_test/4/32024/4089 +- membrane_hipsc_test/4/34998/4271 +- membrane_hipsc_test/4/35284/4501 +- membrane_hipsc_test/4/36643/4930 +- membrane_hipsc_test/4/37601/5175 +- membrane_hipsc_test/4/38464/5176 +- membrane_hipsc_test/4/4556/15828 +- membrane_hipsc_test/4/4556/16242 +- membrane_hipsc_test/4/5910/824 +- membrane_hipsc_test/4/6497/1014 +- membrane_hipsc_test/4/6775/1242 +- membrane_hipsc_test/4/8706/1138 +- membrane_hipsc_test/4/94507/699 +- membrane_hipsc_test/41/44212/5751 +- membrane_hipsc_test/41/48436/5515 +- membrane_hipsc_test/41/48536/5593 +- membrane_hipsc_test/41/49121/5716 +- membrane_hipsc_test/41/49121/5777 +- membrane_hipsc_test/41/49204/5680 +- membrane_hipsc_test/41/49888/5888 +- membrane_hipsc_test/41/49975/5926 +- membrane_hipsc_test/41/50548/6016 +- membrane_hipsc_test/41/52564/5966 +- membrane_hipsc_test/41/53048/15203 +- membrane_hipsc_test/41/55160/6367 +- membrane_hipsc_test/41/55348/6437 +- membrane_hipsc_test/41/55350/6427 +- membrane_hipsc_test/41/58326/6874 +- membrane_hipsc_test/41/58517/6781 +- membrane_hipsc_test/41/60728/7413 +- membrane_hipsc_test/41/62754/7076 +- membrane_hipsc_test/41/63524/7359 +- membrane_hipsc_test/41/63524/7400 +- membrane_hipsc_test/41/63713/7287 +- membrane_hipsc_test/41/66020/7541 +- membrane_hipsc_test/41/67168/7688 +- membrane_hipsc_test/41/68116/7831 +- membrane_hipsc_test/41/68598/9132 +- membrane_hipsc_test/41/68804/8999 +- membrane_hipsc_test/41/68884/9247 +- membrane_hipsc_test/41/68885/9316 +- membrane_hipsc_test/41/70240/9487 +- membrane_hipsc_test/41/72356/7974 +- membrane_hipsc_test/41/72629/8071 +- membrane_hipsc_test/41/72725/8138 +- membrane_hipsc_test/41/72727/8125 +- membrane_hipsc_test/41/73112/8476 +- membrane_hipsc_test/41/73304/8259 +- membrane_hipsc_test/41/73686/8660 +- membrane_hipsc_test/41/73686/8668 +- membrane_hipsc_test/41/73783/8567 +- membrane_hipsc_test/41/74264/8751 +- membrane_hipsc_test/41/74272/8740 +- membrane_hipsc_test/41/74356/8919 +- membrane_hipsc_test/41/75800/8019 +- membrane_hipsc_test/41/75808/7975 +- membrane_hipsc_test/42/107478/10817 +- membrane_hipsc_test/42/114584/12053 +- membrane_hipsc_test/42/115556/15421 +- membrane_hipsc_test/42/116598/10604 +- membrane_hipsc_test/42/117557/11343 +- membrane_hipsc_test/42/118901/11674 +- membrane_hipsc_test/42/118912/11694 +- membrane_hipsc_test/42/123916/16655 +- membrane_hipsc_test/42/124001/16229 +- membrane_hipsc_test/42/127171/12338 +- membrane_hipsc_test/42/127276/23725 +- membrane_hipsc_test/42/127939/12482 +- membrane_hipsc_test/42/128428/12536 +- membrane_hipsc_test/42/128523/12637 +- membrane_hipsc_test/42/129665/12780 +- membrane_hipsc_test/42/129855/12890 +- membrane_hipsc_test/42/132463/13304 +- membrane_hipsc_test/42/132834/13446 +- membrane_hipsc_test/42/133599/13746 +- membrane_hipsc_test/42/135439/14132 +- membrane_hipsc_test/42/137449/14744 +- membrane_hipsc_test/42/137455/14731 +- membrane_hipsc_test/42/137460/14685 +- membrane_hipsc_test/42/137582/14642 +- membrane_hipsc_test/42/137774/14522 +- membrane_hipsc_test/42/137820/14488 +- membrane_hipsc_test/42/137953/15518 +- membrane_hipsc_test/42/77924/9512 +- membrane_hipsc_test/42/80023/9994 +- membrane_hipsc_test/42/82708/16181 +- membrane_hipsc_test/42/84449/15422 +- caax_a549_mantis_2026_03_26_test/B/2/000001 +- caax_a549_mantis_2026_03_26_test/B/2/000004 +- caax_a549_mantis_2026_03_26_test/B/2/000007 +- caax_a549_mantis_2026_03_26_test/B/2/003001 +- caax_a549_mantis_2026_03_26_test/B/2/003004 +- caax_a549_mantis_2026_03_26_test/B/2/003007 +- caax_a549_mantis_2026_03_26_test/B/2/005001 +- caax_a549_mantis_2026_03_26_test/B/2/005004 +- caax_a549_mantis_2026_03_26_test/B/2/005007 +- caax_a549_mantis_2026_03_26_test/B/2/008001 +- caax_a549_mantis_2026_03_26_test/B/2/008004 +- caax_a549_mantis_2026_03_26_test/B/2/008007 diff --git a/applications/dynacell/configs/collections/virtual_staining/nucleus_ipsc_v1.yaml b/applications/dynacell/configs/collections/virtual_staining/nucleus_ipsc_v1.yaml new file mode 100644 index 000000000..c6d076bcc --- /dev/null +++ b/applications/dynacell/configs/collections/virtual_staining/nucleus_ipsc_v1.yaml @@ -0,0 +1,658 @@ +name: nucleus_ipsc_v1 +description: Frozen benchmark collection for 'aics-hipsc' target 'nucleus'. Channels + and FOV membership captured from the live train/test zarr stores at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-27T12:02:09.776033+00:00' + created_by: Alex Kalinin +experiments: +- name: nucleus_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Nuclei + organelle: nucleus + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: nucleus_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Nuclei + organelle: nucleus + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +train_fovs: +- nucleus_hipsc_train/4/10615/1304 +- nucleus_hipsc_train/4/10625/1347 +- nucleus_hipsc_train/4/10900/1427 +- nucleus_hipsc_train/4/10904/1436 +- nucleus_hipsc_train/4/11384/1404 +- nucleus_hipsc_train/4/11478/1468 +- nucleus_hipsc_train/4/11490/1466 +- nucleus_hipsc_train/4/11492/1467 +- nucleus_hipsc_train/4/11573/1414 +- nucleus_hipsc_train/4/136707/16750 +- nucleus_hipsc_train/4/136710/15363 +- nucleus_hipsc_train/4/136721/16107 +- nucleus_hipsc_train/4/136725/15834 +- nucleus_hipsc_train/4/13974/1528 +- nucleus_hipsc_train/4/14646/1871 +- nucleus_hipsc_train/4/14740/1745 +- nucleus_hipsc_train/4/14742/1791 +- nucleus_hipsc_train/4/14754/1781 +- nucleus_hipsc_train/4/1493/268 +- nucleus_hipsc_train/4/1508/255 +- nucleus_hipsc_train/4/16278/2186 +- nucleus_hipsc_train/4/16376/2374 +- nucleus_hipsc_train/4/16468/2321 +- nucleus_hipsc_train/4/16469/2337 +- nucleus_hipsc_train/4/16469/2339 +- nucleus_hipsc_train/4/16469/2345 +- nucleus_hipsc_train/4/16471/2265 +- nucleus_hipsc_train/4/16472/2312 +- nucleus_hipsc_train/4/16951/2459 +- nucleus_hipsc_train/4/16951/2480 +- nucleus_hipsc_train/4/16952/2494 +- nucleus_hipsc_train/4/17333/2710 +- nucleus_hipsc_train/4/17348/16148 +- nucleus_hipsc_train/4/17525/2811 +- nucleus_hipsc_train/4/17526/2752 +- nucleus_hipsc_train/4/17536/2773 +- nucleus_hipsc_train/4/18020/1618 +- nucleus_hipsc_train/4/18020/1625 +- nucleus_hipsc_train/4/18020/1638 +- nucleus_hipsc_train/4/18487/1811 +- nucleus_hipsc_train/4/19351/1905 +- nucleus_hipsc_train/4/19543/2105 +- nucleus_hipsc_train/4/19554/2020 +- nucleus_hipsc_train/4/19556/2089 +- nucleus_hipsc_train/4/20416/2223 +- nucleus_hipsc_train/4/20596/2406 +- nucleus_hipsc_train/4/20597/2395 +- nucleus_hipsc_train/4/20597/2401 +- nucleus_hipsc_train/4/20599/2373 +- nucleus_hipsc_train/4/21077/2254 +- nucleus_hipsc_train/4/21089/2293 +- nucleus_hipsc_train/4/21556/2491 +- nucleus_hipsc_train/4/21557/2483 +- nucleus_hipsc_train/4/21557/2527 +- nucleus_hipsc_train/4/21653/2547 +- nucleus_hipsc_train/4/21860/15671 +- nucleus_hipsc_train/4/21940/2736 +- nucleus_hipsc_train/4/21943/2717 +- nucleus_hipsc_train/4/21953/2739 +- nucleus_hipsc_train/4/22133/2826 +- nucleus_hipsc_train/4/22136/2827 +- nucleus_hipsc_train/4/22339/3095 +- nucleus_hipsc_train/4/22340/3097 +- nucleus_hipsc_train/4/22612/2915 +- nucleus_hipsc_train/4/22614/2923 +- nucleus_hipsc_train/4/22615/2978 +- nucleus_hipsc_train/4/22624/2909 +- nucleus_hipsc_train/4/22709/3070 +- nucleus_hipsc_train/4/22712/3090 +- nucleus_hipsc_train/4/22913/3301 +- nucleus_hipsc_train/4/22914/3289 +- nucleus_hipsc_train/4/23380/3237 +- nucleus_hipsc_train/4/23392/3212 +- nucleus_hipsc_train/4/23395/3223 +- nucleus_hipsc_train/4/23574/3492 +- nucleus_hipsc_train/4/23764/3409 +- nucleus_hipsc_train/4/24152/3567 +- nucleus_hipsc_train/4/24724/3661 +- nucleus_hipsc_train/4/24727/3659 +- nucleus_hipsc_train/4/24928/3585 +- nucleus_hipsc_train/4/25784/3851 +- nucleus_hipsc_train/4/27800/2883 +- nucleus_hipsc_train/4/27896/2943 +- nucleus_hipsc_train/4/27992/3020 +- nucleus_hipsc_train/4/28084/3214 +- nucleus_hipsc_train/4/28084/3270 +- nucleus_hipsc_train/4/28087/3266 +- nucleus_hipsc_train/4/28756/3381 +- nucleus_hipsc_train/4/28759/3393 +- nucleus_hipsc_train/4/29045/3764 +- nucleus_hipsc_train/4/29060/3753 +- nucleus_hipsc_train/4/29143/3667 +- nucleus_hipsc_train/4/29155/3710 +- nucleus_hipsc_train/4/2932/230 +- nucleus_hipsc_train/4/29333/3908 +- nucleus_hipsc_train/4/2945/173 +- nucleus_hipsc_train/4/30292/14379 +- nucleus_hipsc_train/4/30293/3905 +- nucleus_hipsc_train/4/30308/3869 +- nucleus_hipsc_train/4/30388/16862 +- nucleus_hipsc_train/4/30389/15342 +- nucleus_hipsc_train/4/30392/16741 +- nucleus_hipsc_train/4/31732/17059 +- nucleus_hipsc_train/4/31744/16779 +- nucleus_hipsc_train/4/31841/3962 +- nucleus_hipsc_train/4/31939/3975 +- nucleus_hipsc_train/4/32024/4077 +- nucleus_hipsc_train/4/32033/4111 +- nucleus_hipsc_train/4/32033/4121 +- nucleus_hipsc_train/4/32035/4099 +- nucleus_hipsc_train/4/33077/4379 +- nucleus_hipsc_train/4/33572/4229 +- nucleus_hipsc_train/4/33942/15337 +- nucleus_hipsc_train/4/33942/16205 +- nucleus_hipsc_train/4/33943/17061 +- nucleus_hipsc_train/4/33953/16561 +- nucleus_hipsc_train/4/33955/16023 +- nucleus_hipsc_train/4/34038/4363 +- nucleus_hipsc_train/4/34808/4417 +- nucleus_hipsc_train/4/35000/4274 +- nucleus_hipsc_train/4/35284/4472 +- nucleus_hipsc_train/4/35287/4460 +- nucleus_hipsc_train/4/35479/4551 +- nucleus_hipsc_train/4/35489/4583 +- nucleus_hipsc_train/4/36449/15327 +- nucleus_hipsc_train/4/36544/4909 +- nucleus_hipsc_train/4/36544/4931 +- nucleus_hipsc_train/4/36628/4907 +- nucleus_hipsc_train/4/36836/4996 +- nucleus_hipsc_train/4/37591/5133 +- nucleus_hipsc_train/4/37603/5147 +- nucleus_hipsc_train/4/37972/5388 +- nucleus_hipsc_train/4/37988/5373 +- nucleus_hipsc_train/4/40084/5359 +- nucleus_hipsc_train/4/40086/5362 +- nucleus_hipsc_train/4/40376/4584 +- nucleus_hipsc_train/4/40385/4614 +- nucleus_hipsc_train/4/40386/4613 +- nucleus_hipsc_train/4/40387/4586 +- nucleus_hipsc_train/4/40483/4619 +- nucleus_hipsc_train/4/40483/4621 +- nucleus_hipsc_train/4/40960/4654 +- nucleus_hipsc_train/4/41044/4851 +- nucleus_hipsc_train/4/41047/4885 +- nucleus_hipsc_train/4/41237/4861 +- nucleus_hipsc_train/4/41249/4835 +- nucleus_hipsc_train/4/41912/5074 +- nucleus_hipsc_train/4/5143/954 +- nucleus_hipsc_train/4/5236/869 +- nucleus_hipsc_train/4/5238/875 +- nucleus_hipsc_train/4/6485/1018 +- nucleus_hipsc_train/4/6486/992 +- nucleus_hipsc_train/4/6497/1003 +- nucleus_hipsc_train/4/6775/1203 +- nucleus_hipsc_train/4/6775/1226 +- nucleus_hipsc_train/4/6775/1236 +- nucleus_hipsc_train/4/7156/1124 +- nucleus_hipsc_train/4/7349/1355 +- nucleus_hipsc_train/4/7650/1278 +- nucleus_hipsc_train/4/8214/878 +- nucleus_hipsc_train/4/8214/879 +- nucleus_hipsc_train/4/8228/898 +- nucleus_hipsc_train/4/8695/1215 +- nucleus_hipsc_train/4/88267/15294 +- nucleus_hipsc_train/4/89048/356 +- nucleus_hipsc_train/4/8982/1171 +- nucleus_hipsc_train/4/90088/415 +- nucleus_hipsc_train/4/90858/15658 +- nucleus_hipsc_train/4/90858/16534 +- nucleus_hipsc_train/4/91144/102 +- nucleus_hipsc_train/4/91924/458 +- nucleus_hipsc_train/4/93448/596 +- nucleus_hipsc_train/4/94312/684 +- nucleus_hipsc_train/4/95752/811 +- nucleus_hipsc_train/4/95753/737 +- nucleus_hipsc_train/4/95753/872 +- nucleus_hipsc_train/41/43638/5246 +- nucleus_hipsc_train/41/43639/5265 +- nucleus_hipsc_train/41/43732/16519 +- nucleus_hipsc_train/41/45556/5706 +- nucleus_hipsc_train/41/45556/5734 +- nucleus_hipsc_train/41/45559/5714 +- nucleus_hipsc_train/41/48436/5507 +- nucleus_hipsc_train/41/48534/5575 +- nucleus_hipsc_train/41/48535/5623 +- nucleus_hipsc_train/41/48548/5574 +- nucleus_hipsc_train/41/48548/5589 +- nucleus_hipsc_train/41/49204/5661 +- nucleus_hipsc_train/41/49220/5671 +- nucleus_hipsc_train/41/49698/5819 +- nucleus_hipsc_train/41/49972/5933 +- nucleus_hipsc_train/41/49973/5960 +- nucleus_hipsc_train/41/50263/6077 +- nucleus_hipsc_train/41/50263/6082 +- nucleus_hipsc_train/41/50356/15510 +- nucleus_hipsc_train/41/50356/15578 +- nucleus_hipsc_train/41/50359/15457 +- nucleus_hipsc_train/41/50548/6024 +- nucleus_hipsc_train/41/50551/6022 +- nucleus_hipsc_train/41/53044/15243 +- nucleus_hipsc_train/41/53046/16965 +- nucleus_hipsc_train/41/53428/6238 +- nucleus_hipsc_train/41/53524/15636 +- nucleus_hipsc_train/41/53538/15395 +- nucleus_hipsc_train/41/53731/15920 +- nucleus_hipsc_train/41/55156/6355 +- nucleus_hipsc_train/41/55156/6358 +- nucleus_hipsc_train/41/55158/6324 +- nucleus_hipsc_train/41/55158/6353 +- nucleus_hipsc_train/41/55253/6499 +- nucleus_hipsc_train/41/55256/6482 +- nucleus_hipsc_train/41/55351/6419 +- nucleus_hipsc_train/41/55363/6362 +- nucleus_hipsc_train/41/55925/6584 +- nucleus_hipsc_train/41/56406/6643 +- nucleus_hipsc_train/41/56416/6614 +- nucleus_hipsc_train/41/56418/6626 +- nucleus_hipsc_train/41/56419/6630 +- nucleus_hipsc_train/41/56596/6678 +- nucleus_hipsc_train/41/56896/7720 +- nucleus_hipsc_train/41/57364/6456 +- nucleus_hipsc_train/41/57365/6428 +- nucleus_hipsc_train/41/57367/6430 +- nucleus_hipsc_train/41/57464/6544 +- nucleus_hipsc_train/41/57472/6556 +- nucleus_hipsc_train/41/57472/6565 +- nucleus_hipsc_train/41/58134/6821 +- nucleus_hipsc_train/41/58326/6840 +- nucleus_hipsc_train/41/58420/6971 +- nucleus_hipsc_train/41/58423/6963 +- nucleus_hipsc_train/41/58518/6786 +- nucleus_hipsc_train/41/59285/7118 +- nucleus_hipsc_train/41/59285/7124 +- nucleus_hipsc_train/41/59298/7175 +- nucleus_hipsc_train/41/59380/7015 +- nucleus_hipsc_train/41/59479/7188 +- nucleus_hipsc_train/41/59479/7200 +- nucleus_hipsc_train/41/59480/7179 +- nucleus_hipsc_train/41/60548/7475 +- nucleus_hipsc_train/41/60632/7345 +- nucleus_hipsc_train/41/60726/7399 +- nucleus_hipsc_train/41/60737/7332 +- nucleus_hipsc_train/41/60738/7414 +- nucleus_hipsc_train/41/62740/7068 +- nucleus_hipsc_train/41/62932/6916 +- nucleus_hipsc_train/41/63508/7389 +- nucleus_hipsc_train/41/63523/7383 +- nucleus_hipsc_train/41/63608/7462 +- nucleus_hipsc_train/41/63608/7464 +- nucleus_hipsc_train/41/63620/7451 +- nucleus_hipsc_train/41/63701/7283 +- nucleus_hipsc_train/41/63713/7256 +- nucleus_hipsc_train/41/66292/7775 +- nucleus_hipsc_train/41/66292/7782 +- nucleus_hipsc_train/41/66292/7796 +- nucleus_hipsc_train/41/66296/7788 +- nucleus_hipsc_train/41/67157/7690 +- nucleus_hipsc_train/41/67168/7678 +- nucleus_hipsc_train/41/68131/7834 +- nucleus_hipsc_train/41/68503/9206 +- nucleus_hipsc_train/41/68504/9176 +- nucleus_hipsc_train/41/68504/9197 +- nucleus_hipsc_train/41/68512/9188 +- nucleus_hipsc_train/41/68512/9207 +- nucleus_hipsc_train/41/68512/9212 +- nucleus_hipsc_train/41/68708/9065 +- nucleus_hipsc_train/41/68788/9030 +- nucleus_hipsc_train/41/68800/9019 +- nucleus_hipsc_train/41/69472/9285 +- nucleus_hipsc_train/41/69473/9279 +- nucleus_hipsc_train/41/69474/9306 +- nucleus_hipsc_train/41/70052/15689 +- nucleus_hipsc_train/41/70231/9525 +- nucleus_hipsc_train/41/70232/9551 +- nucleus_hipsc_train/41/72244/8037 +- nucleus_hipsc_train/41/72244/8074 +- nucleus_hipsc_train/41/72256/8049 +- nucleus_hipsc_train/41/72260/8085 +- nucleus_hipsc_train/41/72342/7994 +- nucleus_hipsc_train/41/72356/7962 +- nucleus_hipsc_train/41/72628/8109 +- nucleus_hipsc_train/41/72629/8086 +- nucleus_hipsc_train/41/72630/8119 +- nucleus_hipsc_train/41/72631/8095 +- nucleus_hipsc_train/41/72725/8151 +- nucleus_hipsc_train/41/72726/8128 +- nucleus_hipsc_train/41/72834/8288 +- nucleus_hipsc_train/41/73300/8255 +- nucleus_hipsc_train/41/73396/8265 +- nucleus_hipsc_train/41/73397/8271 +- nucleus_hipsc_train/41/73398/8307 +- nucleus_hipsc_train/41/73495/8186 +- nucleus_hipsc_train/41/73507/8203 +- nucleus_hipsc_train/41/73685/8634 +- nucleus_hipsc_train/41/73687/8628 +- nucleus_hipsc_train/41/73700/8663 +- nucleus_hipsc_train/41/73782/8525 +- nucleus_hipsc_train/41/73782/8576 +- nucleus_hipsc_train/41/73783/8530 +- nucleus_hipsc_train/41/73784/8543 +- nucleus_hipsc_train/41/73879/15995 +- nucleus_hipsc_train/41/73975/15832 +- nucleus_hipsc_train/41/74165/8821 +- nucleus_hipsc_train/41/74168/8793 +- nucleus_hipsc_train/41/74260/8727 +- nucleus_hipsc_train/41/74273/8721 +- nucleus_hipsc_train/41/74371/8941 +- nucleus_hipsc_train/41/74371/8978 +- nucleus_hipsc_train/41/75042/7915 +- nucleus_hipsc_train/41/75124/16978 +- nucleus_hipsc_train/41/75125/16693 +- nucleus_hipsc_train/41/75512/7872 +- nucleus_hipsc_train/41/75796/7941 +- nucleus_hipsc_train/41/75799/7953 +- nucleus_hipsc_train/41/76000/8244 +- nucleus_hipsc_train/41/77250/8868 +- nucleus_hipsc_train/41/77333/9094 +- nucleus_hipsc_train/42/106420/10373 +- nucleus_hipsc_train/42/106421/10380 +- nucleus_hipsc_train/42/106422/10368 +- nucleus_hipsc_train/42/106516/10272 +- nucleus_hipsc_train/42/106518/10239 +- nucleus_hipsc_train/42/106520/10262 +- nucleus_hipsc_train/42/106915/10747 +- nucleus_hipsc_train/42/106996/10652 +- nucleus_hipsc_train/42/106998/10641 +- nucleus_hipsc_train/42/107480/10815 +- nucleus_hipsc_train/42/107480/10822 +- nucleus_hipsc_train/42/107572/12022 +- nucleus_hipsc_train/42/107574/11982 +- nucleus_hipsc_train/42/107574/12039 +- nucleus_hipsc_train/42/107682/11895 +- nucleus_hipsc_train/42/107682/11898 +- nucleus_hipsc_train/42/107684/11928 +- nucleus_hipsc_train/42/107956/11969 +- nucleus_hipsc_train/42/107956/11981 +- nucleus_hipsc_train/42/107958/11911 +- nucleus_hipsc_train/42/107959/12029 +- nucleus_hipsc_train/42/107972/11941 +- nucleus_hipsc_train/42/108148/15673 +- nucleus_hipsc_train/42/108149/12190 +- nucleus_hipsc_train/42/108246/11135 +- nucleus_hipsc_train/42/108248/16355 +- nucleus_hipsc_train/42/108824/15581 +- nucleus_hipsc_train/42/108833/15155 +- nucleus_hipsc_train/42/110548/10130 +- nucleus_hipsc_train/42/110552/10154 +- nucleus_hipsc_train/42/110552/10175 +- nucleus_hipsc_train/42/110645/10108 +- nucleus_hipsc_train/42/110646/10124 +- nucleus_hipsc_train/42/110660/10091 +- nucleus_hipsc_train/42/110947/10199 +- nucleus_hipsc_train/42/111125/10242 +- nucleus_hipsc_train/42/111413/10485 +- nucleus_hipsc_train/42/111415/10486 +- nucleus_hipsc_train/42/111426/10473 +- nucleus_hipsc_train/42/111892/10724 +- nucleus_hipsc_train/42/112084/15061 +- nucleus_hipsc_train/42/112085/16293 +- nucleus_hipsc_train/42/112280/15454 +- nucleus_hipsc_train/42/112565/10904 +- nucleus_hipsc_train/42/112758/16064 +- nucleus_hipsc_train/42/112772/14973 +- nucleus_hipsc_train/42/113432/11852 +- nucleus_hipsc_train/42/113634/10939 +- nucleus_hipsc_train/42/113921/11053 +- nucleus_hipsc_train/42/114209/10977 +- nucleus_hipsc_train/42/114212/10981 +- nucleus_hipsc_train/42/114787/11121 +- nucleus_hipsc_train/42/114788/11097 +- nucleus_hipsc_train/42/114965/11232 +- nucleus_hipsc_train/42/114965/11269 +- nucleus_hipsc_train/42/114979/11222 +- nucleus_hipsc_train/42/115160/12126 +- nucleus_hipsc_train/42/115169/16617 +- nucleus_hipsc_train/42/115349/11410 +- nucleus_hipsc_train/42/115541/15346 +- nucleus_hipsc_train/42/115542/16879 +- nucleus_hipsc_train/42/115552/15185 +- nucleus_hipsc_train/42/115554/15716 +- nucleus_hipsc_train/42/115555/16425 +- nucleus_hipsc_train/42/115556/15703 +- nucleus_hipsc_train/42/115831/11479 +- nucleus_hipsc_train/42/116034/11497 +- nucleus_hipsc_train/42/116309/11595 +- nucleus_hipsc_train/42/116324/11616 +- nucleus_hipsc_train/42/116608/10515 +- nucleus_hipsc_train/42/116608/10614 +- nucleus_hipsc_train/42/116887/10440 +- nucleus_hipsc_train/42/116897/10412 +- nucleus_hipsc_train/42/116900/10422 +- nucleus_hipsc_train/42/117173/10673 +- nucleus_hipsc_train/42/117186/10657 +- nucleus_hipsc_train/42/117557/11347 +- nucleus_hipsc_train/42/117559/11367 +- nucleus_hipsc_train/42/117572/11385 +- nucleus_hipsc_train/42/117847/11299 +- nucleus_hipsc_train/42/118420/11731 +- nucleus_hipsc_train/42/118423/11658 +- nucleus_hipsc_train/42/118712/11569 +- nucleus_hipsc_train/42/118806/11804 +- nucleus_hipsc_train/42/118808/11800 +- nucleus_hipsc_train/42/121791/16666 +- nucleus_hipsc_train/42/121793/15852 +- nucleus_hipsc_train/42/121806/15946 +- nucleus_hipsc_train/42/123328/15550 +- nucleus_hipsc_train/42/123328/17092 +- nucleus_hipsc_train/42/123714/16851 +- nucleus_hipsc_train/42/123903/15431 +- nucleus_hipsc_train/42/124002/16132 +- nucleus_hipsc_train/42/124014/16885 +- nucleus_hipsc_train/42/124205/15565 +- nucleus_hipsc_train/42/124287/15382 +- nucleus_hipsc_train/42/124290/15483 +- nucleus_hipsc_train/42/124291/15731 +- nucleus_hipsc_train/42/124299/16712 +- nucleus_hipsc_train/42/124301/15843 +- nucleus_hipsc_train/42/127171/12333 +- nucleus_hipsc_train/42/127647/12252 +- nucleus_hipsc_train/42/127648/12223 +- nucleus_hipsc_train/42/127649/12208 +- nucleus_hipsc_train/42/127650/12238 +- nucleus_hipsc_train/42/127650/12256 +- nucleus_hipsc_train/42/127651/12217 +- nucleus_hipsc_train/42/127651/12239 +- nucleus_hipsc_train/42/127852/12320 +- nucleus_hipsc_train/42/127935/12457 +- nucleus_hipsc_train/42/127947/12485 +- nucleus_hipsc_train/42/128416/12512 +- nucleus_hipsc_train/42/128514/12657 +- nucleus_hipsc_train/42/128514/12667 +- nucleus_hipsc_train/42/128525/12654 +- nucleus_hipsc_train/42/128715/12598 +- nucleus_hipsc_train/42/128718/12626 +- nucleus_hipsc_train/42/128719/12625 +- nucleus_hipsc_train/42/129473/12830 +- nucleus_hipsc_train/42/129473/12852 +- nucleus_hipsc_train/42/129571/12811 +- nucleus_hipsc_train/42/129583/12802 +- nucleus_hipsc_train/42/129774/12715 +- nucleus_hipsc_train/42/129855/12931 +- nucleus_hipsc_train/42/130155/13043 +- nucleus_hipsc_train/42/130527/12960 +- nucleus_hipsc_train/42/130625/16186 +- nucleus_hipsc_train/42/130707/13231 +- nucleus_hipsc_train/42/130722/17097 +- nucleus_hipsc_train/42/132173/13409 +- nucleus_hipsc_train/42/132175/13365 +- nucleus_hipsc_train/42/132653/13278 +- nucleus_hipsc_train/42/132831/13415 +- nucleus_hipsc_train/42/132844/13432 +- nucleus_hipsc_train/42/132845/13448 +- nucleus_hipsc_train/42/132929/13513 +- nucleus_hipsc_train/42/133133/13640 +- nucleus_hipsc_train/42/133323/13465 +- nucleus_hipsc_train/42/133324/13457 +- nucleus_hipsc_train/42/133325/13497 +- nucleus_hipsc_train/42/133503/13577 +- nucleus_hipsc_train/42/133504/13572 +- nucleus_hipsc_train/42/133602/13711 +- nucleus_hipsc_train/42/133711/13788 +- nucleus_hipsc_train/42/134272/13918 +- nucleus_hipsc_train/42/134286/13916 +- nucleus_hipsc_train/42/134656/13884 +- nucleus_hipsc_train/42/135272/14059 +- nucleus_hipsc_train/42/135440/14128 +- nucleus_hipsc_train/42/135525/14245 +- nucleus_hipsc_train/42/135614/14178 +- nucleus_hipsc_train/42/137434/14771 +- nucleus_hipsc_train/42/137464/14708 +- nucleus_hipsc_train/42/137767/14413 +- nucleus_hipsc_train/42/137772/14516 +- nucleus_hipsc_train/42/137956/15501 +- nucleus_hipsc_train/42/137956/16613 +- nucleus_hipsc_train/42/137956/17196 +- nucleus_hipsc_train/42/137956/17224 +- nucleus_hipsc_train/42/138024/15890 +- nucleus_hipsc_train/42/138028/16174 +- nucleus_hipsc_train/42/138032/15577 +- nucleus_hipsc_train/42/138261/16083 +- nucleus_hipsc_train/42/77912/9479 +- nucleus_hipsc_train/42/77912/9520 +- nucleus_hipsc_train/42/77923/9543 +- nucleus_hipsc_train/42/78389/9675 +- nucleus_hipsc_train/42/78391/9672 +- nucleus_hipsc_train/42/78487/9750 +- nucleus_hipsc_train/42/78487/9758 +- nucleus_hipsc_train/42/78691/9802 +- nucleus_hipsc_train/42/79541/9897 +- nucleus_hipsc_train/42/79552/9894 +- nucleus_hipsc_train/42/79554/9874 +- nucleus_hipsc_train/42/79828/9972 +- nucleus_hipsc_train/42/79831/9969 +- nucleus_hipsc_train/42/79832/9978 +- nucleus_hipsc_train/42/79841/9963 +- nucleus_hipsc_train/42/80023/15006 +- nucleus_hipsc_train/42/80033/15189 +- nucleus_hipsc_train/42/80035/9980 +- nucleus_hipsc_train/42/80224/9960 +- nucleus_hipsc_train/42/83392/9630 +test_fovs: +- nucleus_hipsc_test/4/11393/1428 +- nucleus_hipsc_test/4/11479/1481 +- nucleus_hipsc_test/4/18007/1641 +- nucleus_hipsc_test/4/18102/1710 +- nucleus_hipsc_test/4/18485/1842 +- nucleus_hipsc_test/4/22901/3306 +- nucleus_hipsc_test/4/27797/2857 +- nucleus_hipsc_test/4/28759/3400 +- nucleus_hipsc_test/4/29060/3786 +- nucleus_hipsc_test/4/29140/3687 +- nucleus_hipsc_test/4/29334/3890 +- nucleus_hipsc_test/4/30293/3915 +- nucleus_hipsc_test/4/31736/15232 +- nucleus_hipsc_test/4/32024/4089 +- nucleus_hipsc_test/4/34998/4271 +- nucleus_hipsc_test/4/35284/4501 +- nucleus_hipsc_test/4/36643/4930 +- nucleus_hipsc_test/4/37601/5175 +- nucleus_hipsc_test/4/38464/5176 +- nucleus_hipsc_test/4/4556/15828 +- nucleus_hipsc_test/4/4556/16242 +- nucleus_hipsc_test/4/5910/824 +- nucleus_hipsc_test/4/6497/1014 +- nucleus_hipsc_test/4/6775/1242 +- nucleus_hipsc_test/4/8706/1138 +- nucleus_hipsc_test/4/94507/699 +- nucleus_hipsc_test/41/44212/5751 +- nucleus_hipsc_test/41/48436/5515 +- nucleus_hipsc_test/41/48536/5593 +- nucleus_hipsc_test/41/49121/5716 +- nucleus_hipsc_test/41/49121/5777 +- nucleus_hipsc_test/41/49204/5680 +- nucleus_hipsc_test/41/49888/5888 +- nucleus_hipsc_test/41/49975/5926 +- nucleus_hipsc_test/41/50548/6016 +- nucleus_hipsc_test/41/52564/5966 +- nucleus_hipsc_test/41/53048/15203 +- nucleus_hipsc_test/41/55160/6367 +- nucleus_hipsc_test/41/55348/6437 +- nucleus_hipsc_test/41/55350/6427 +- nucleus_hipsc_test/41/58326/6874 +- nucleus_hipsc_test/41/58517/6781 +- nucleus_hipsc_test/41/60728/7413 +- nucleus_hipsc_test/41/62754/7076 +- nucleus_hipsc_test/41/63524/7359 +- nucleus_hipsc_test/41/63524/7400 +- nucleus_hipsc_test/41/63713/7287 +- nucleus_hipsc_test/41/66020/7541 +- nucleus_hipsc_test/41/67168/7688 +- nucleus_hipsc_test/41/68116/7831 +- nucleus_hipsc_test/41/68598/9132 +- nucleus_hipsc_test/41/68804/8999 +- nucleus_hipsc_test/41/68884/9247 +- nucleus_hipsc_test/41/68885/9316 +- nucleus_hipsc_test/41/70240/9487 +- nucleus_hipsc_test/41/72356/7974 +- nucleus_hipsc_test/41/72629/8071 +- nucleus_hipsc_test/41/72725/8138 +- nucleus_hipsc_test/41/72727/8125 +- nucleus_hipsc_test/41/73112/8476 +- nucleus_hipsc_test/41/73304/8259 +- nucleus_hipsc_test/41/73686/8660 +- nucleus_hipsc_test/41/73686/8668 +- nucleus_hipsc_test/41/73783/8567 +- nucleus_hipsc_test/41/74264/8751 +- nucleus_hipsc_test/41/74272/8740 +- nucleus_hipsc_test/41/74356/8919 +- nucleus_hipsc_test/41/75800/8019 +- nucleus_hipsc_test/41/75808/7975 +- nucleus_hipsc_test/42/107478/10817 +- nucleus_hipsc_test/42/114584/12053 +- nucleus_hipsc_test/42/115556/15421 +- nucleus_hipsc_test/42/116598/10604 +- nucleus_hipsc_test/42/117557/11343 +- nucleus_hipsc_test/42/118901/11674 +- nucleus_hipsc_test/42/118912/11694 +- nucleus_hipsc_test/42/123916/16655 +- nucleus_hipsc_test/42/124001/16229 +- nucleus_hipsc_test/42/127171/12338 +- nucleus_hipsc_test/42/127276/23725 +- nucleus_hipsc_test/42/127939/12482 +- nucleus_hipsc_test/42/128428/12536 +- nucleus_hipsc_test/42/128523/12637 +- nucleus_hipsc_test/42/129665/12780 +- nucleus_hipsc_test/42/129855/12890 +- nucleus_hipsc_test/42/132463/13304 +- nucleus_hipsc_test/42/132834/13446 +- nucleus_hipsc_test/42/133599/13746 +- nucleus_hipsc_test/42/135439/14132 +- nucleus_hipsc_test/42/137449/14744 +- nucleus_hipsc_test/42/137455/14731 +- nucleus_hipsc_test/42/137460/14685 +- nucleus_hipsc_test/42/137582/14642 +- nucleus_hipsc_test/42/137774/14522 +- nucleus_hipsc_test/42/137820/14488 +- nucleus_hipsc_test/42/137953/15518 +- nucleus_hipsc_test/42/77924/9512 +- nucleus_hipsc_test/42/80023/9994 +- nucleus_hipsc_test/42/82708/16181 +- nucleus_hipsc_test/42/84449/15422 diff --git a/applications/dynacell/configs/collections/virtual_staining/nucleus_joint_all_v1.yaml b/applications/dynacell/configs/collections/virtual_staining/nucleus_joint_all_v1.yaml new file mode 100644 index 000000000..dc9981555 --- /dev/null +++ b/applications/dynacell/configs/collections/virtual_staining/nucleus_joint_all_v1.yaml @@ -0,0 +1,941 @@ +name: nucleus_joint_all_v1 +description: Joint frozen benchmark collection across 2 selectors covering targets + 'h2b', 'nucleus'. Channels and FOV membership captured from the live train/test + zarr stores at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-27T12:02:35.822792+00:00' + created_by: Alex Kalinin +experiments: +- name: nucleus_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Nuclei + organelle: nucleus + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: nucleus_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Nuclei + organelle: nucleus + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: h2b_a549_mantis_2026_03_26_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2026_03_26_A549_CAAX_H2B_DENV_ZIKV/train/H2B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: H2B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: H2B + organelle: nucleus + pixel_size_xy_um: 0.116 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: h2b_a549_mantis_2026_03_26_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2026_03_26_A549_CAAX_H2B_DENV_ZIKV/test/H2B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: H2B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: H2B + organelle: nucleus + pixel_size_xy_um: 0.116 + pixel_size_z_um: 0.174 + exclude_fovs: [] +train_fovs: +- nucleus_hipsc_train/4/10615/1304 +- nucleus_hipsc_train/4/10625/1347 +- nucleus_hipsc_train/4/10900/1427 +- nucleus_hipsc_train/4/10904/1436 +- nucleus_hipsc_train/4/11384/1404 +- nucleus_hipsc_train/4/11478/1468 +- nucleus_hipsc_train/4/11490/1466 +- nucleus_hipsc_train/4/11492/1467 +- nucleus_hipsc_train/4/11573/1414 +- nucleus_hipsc_train/4/136707/16750 +- nucleus_hipsc_train/4/136710/15363 +- nucleus_hipsc_train/4/136721/16107 +- nucleus_hipsc_train/4/136725/15834 +- nucleus_hipsc_train/4/13974/1528 +- nucleus_hipsc_train/4/14646/1871 +- nucleus_hipsc_train/4/14740/1745 +- nucleus_hipsc_train/4/14742/1791 +- nucleus_hipsc_train/4/14754/1781 +- nucleus_hipsc_train/4/1493/268 +- nucleus_hipsc_train/4/1508/255 +- nucleus_hipsc_train/4/16278/2186 +- nucleus_hipsc_train/4/16376/2374 +- nucleus_hipsc_train/4/16468/2321 +- nucleus_hipsc_train/4/16469/2337 +- nucleus_hipsc_train/4/16469/2339 +- nucleus_hipsc_train/4/16469/2345 +- nucleus_hipsc_train/4/16471/2265 +- nucleus_hipsc_train/4/16472/2312 +- nucleus_hipsc_train/4/16951/2459 +- nucleus_hipsc_train/4/16951/2480 +- nucleus_hipsc_train/4/16952/2494 +- nucleus_hipsc_train/4/17333/2710 +- nucleus_hipsc_train/4/17348/16148 +- nucleus_hipsc_train/4/17525/2811 +- nucleus_hipsc_train/4/17526/2752 +- nucleus_hipsc_train/4/17536/2773 +- nucleus_hipsc_train/4/18020/1618 +- nucleus_hipsc_train/4/18020/1625 +- nucleus_hipsc_train/4/18020/1638 +- nucleus_hipsc_train/4/18487/1811 +- nucleus_hipsc_train/4/19351/1905 +- nucleus_hipsc_train/4/19543/2105 +- nucleus_hipsc_train/4/19554/2020 +- nucleus_hipsc_train/4/19556/2089 +- nucleus_hipsc_train/4/20416/2223 +- nucleus_hipsc_train/4/20596/2406 +- nucleus_hipsc_train/4/20597/2395 +- nucleus_hipsc_train/4/20597/2401 +- nucleus_hipsc_train/4/20599/2373 +- nucleus_hipsc_train/4/21077/2254 +- nucleus_hipsc_train/4/21089/2293 +- nucleus_hipsc_train/4/21556/2491 +- nucleus_hipsc_train/4/21557/2483 +- nucleus_hipsc_train/4/21557/2527 +- nucleus_hipsc_train/4/21653/2547 +- nucleus_hipsc_train/4/21860/15671 +- nucleus_hipsc_train/4/21940/2736 +- nucleus_hipsc_train/4/21943/2717 +- nucleus_hipsc_train/4/21953/2739 +- nucleus_hipsc_train/4/22133/2826 +- nucleus_hipsc_train/4/22136/2827 +- nucleus_hipsc_train/4/22339/3095 +- nucleus_hipsc_train/4/22340/3097 +- nucleus_hipsc_train/4/22612/2915 +- nucleus_hipsc_train/4/22614/2923 +- nucleus_hipsc_train/4/22615/2978 +- nucleus_hipsc_train/4/22624/2909 +- nucleus_hipsc_train/4/22709/3070 +- nucleus_hipsc_train/4/22712/3090 +- nucleus_hipsc_train/4/22913/3301 +- nucleus_hipsc_train/4/22914/3289 +- nucleus_hipsc_train/4/23380/3237 +- nucleus_hipsc_train/4/23392/3212 +- nucleus_hipsc_train/4/23395/3223 +- nucleus_hipsc_train/4/23574/3492 +- nucleus_hipsc_train/4/23764/3409 +- nucleus_hipsc_train/4/24152/3567 +- nucleus_hipsc_train/4/24724/3661 +- nucleus_hipsc_train/4/24727/3659 +- nucleus_hipsc_train/4/24928/3585 +- nucleus_hipsc_train/4/25784/3851 +- nucleus_hipsc_train/4/27800/2883 +- nucleus_hipsc_train/4/27896/2943 +- nucleus_hipsc_train/4/27992/3020 +- nucleus_hipsc_train/4/28084/3214 +- nucleus_hipsc_train/4/28084/3270 +- nucleus_hipsc_train/4/28087/3266 +- nucleus_hipsc_train/4/28756/3381 +- nucleus_hipsc_train/4/28759/3393 +- nucleus_hipsc_train/4/29045/3764 +- nucleus_hipsc_train/4/29060/3753 +- nucleus_hipsc_train/4/29143/3667 +- nucleus_hipsc_train/4/29155/3710 +- nucleus_hipsc_train/4/2932/230 +- nucleus_hipsc_train/4/29333/3908 +- nucleus_hipsc_train/4/2945/173 +- nucleus_hipsc_train/4/30292/14379 +- nucleus_hipsc_train/4/30293/3905 +- nucleus_hipsc_train/4/30308/3869 +- nucleus_hipsc_train/4/30388/16862 +- nucleus_hipsc_train/4/30389/15342 +- nucleus_hipsc_train/4/30392/16741 +- nucleus_hipsc_train/4/31732/17059 +- nucleus_hipsc_train/4/31744/16779 +- nucleus_hipsc_train/4/31841/3962 +- nucleus_hipsc_train/4/31939/3975 +- nucleus_hipsc_train/4/32024/4077 +- nucleus_hipsc_train/4/32033/4111 +- nucleus_hipsc_train/4/32033/4121 +- nucleus_hipsc_train/4/32035/4099 +- nucleus_hipsc_train/4/33077/4379 +- nucleus_hipsc_train/4/33572/4229 +- nucleus_hipsc_train/4/33942/15337 +- nucleus_hipsc_train/4/33942/16205 +- nucleus_hipsc_train/4/33943/17061 +- nucleus_hipsc_train/4/33953/16561 +- nucleus_hipsc_train/4/33955/16023 +- nucleus_hipsc_train/4/34038/4363 +- nucleus_hipsc_train/4/34808/4417 +- nucleus_hipsc_train/4/35000/4274 +- nucleus_hipsc_train/4/35284/4472 +- nucleus_hipsc_train/4/35287/4460 +- nucleus_hipsc_train/4/35479/4551 +- nucleus_hipsc_train/4/35489/4583 +- nucleus_hipsc_train/4/36449/15327 +- nucleus_hipsc_train/4/36544/4909 +- nucleus_hipsc_train/4/36544/4931 +- nucleus_hipsc_train/4/36628/4907 +- nucleus_hipsc_train/4/36836/4996 +- nucleus_hipsc_train/4/37591/5133 +- nucleus_hipsc_train/4/37603/5147 +- nucleus_hipsc_train/4/37972/5388 +- nucleus_hipsc_train/4/37988/5373 +- nucleus_hipsc_train/4/40084/5359 +- nucleus_hipsc_train/4/40086/5362 +- nucleus_hipsc_train/4/40376/4584 +- nucleus_hipsc_train/4/40385/4614 +- nucleus_hipsc_train/4/40386/4613 +- nucleus_hipsc_train/4/40387/4586 +- nucleus_hipsc_train/4/40483/4619 +- nucleus_hipsc_train/4/40483/4621 +- nucleus_hipsc_train/4/40960/4654 +- nucleus_hipsc_train/4/41044/4851 +- nucleus_hipsc_train/4/41047/4885 +- nucleus_hipsc_train/4/41237/4861 +- nucleus_hipsc_train/4/41249/4835 +- nucleus_hipsc_train/4/41912/5074 +- nucleus_hipsc_train/4/5143/954 +- nucleus_hipsc_train/4/5236/869 +- nucleus_hipsc_train/4/5238/875 +- nucleus_hipsc_train/4/6485/1018 +- nucleus_hipsc_train/4/6486/992 +- nucleus_hipsc_train/4/6497/1003 +- nucleus_hipsc_train/4/6775/1203 +- nucleus_hipsc_train/4/6775/1226 +- nucleus_hipsc_train/4/6775/1236 +- nucleus_hipsc_train/4/7156/1124 +- nucleus_hipsc_train/4/7349/1355 +- nucleus_hipsc_train/4/7650/1278 +- nucleus_hipsc_train/4/8214/878 +- nucleus_hipsc_train/4/8214/879 +- nucleus_hipsc_train/4/8228/898 +- nucleus_hipsc_train/4/8695/1215 +- nucleus_hipsc_train/4/88267/15294 +- nucleus_hipsc_train/4/89048/356 +- nucleus_hipsc_train/4/8982/1171 +- nucleus_hipsc_train/4/90088/415 +- nucleus_hipsc_train/4/90858/15658 +- nucleus_hipsc_train/4/90858/16534 +- nucleus_hipsc_train/4/91144/102 +- nucleus_hipsc_train/4/91924/458 +- nucleus_hipsc_train/4/93448/596 +- nucleus_hipsc_train/4/94312/684 +- nucleus_hipsc_train/4/95752/811 +- nucleus_hipsc_train/4/95753/737 +- nucleus_hipsc_train/4/95753/872 +- nucleus_hipsc_train/41/43638/5246 +- nucleus_hipsc_train/41/43639/5265 +- nucleus_hipsc_train/41/43732/16519 +- nucleus_hipsc_train/41/45556/5706 +- nucleus_hipsc_train/41/45556/5734 +- nucleus_hipsc_train/41/45559/5714 +- nucleus_hipsc_train/41/48436/5507 +- nucleus_hipsc_train/41/48534/5575 +- nucleus_hipsc_train/41/48535/5623 +- nucleus_hipsc_train/41/48548/5574 +- nucleus_hipsc_train/41/48548/5589 +- nucleus_hipsc_train/41/49204/5661 +- nucleus_hipsc_train/41/49220/5671 +- nucleus_hipsc_train/41/49698/5819 +- nucleus_hipsc_train/41/49972/5933 +- nucleus_hipsc_train/41/49973/5960 +- nucleus_hipsc_train/41/50263/6077 +- nucleus_hipsc_train/41/50263/6082 +- nucleus_hipsc_train/41/50356/15510 +- nucleus_hipsc_train/41/50356/15578 +- nucleus_hipsc_train/41/50359/15457 +- nucleus_hipsc_train/41/50548/6024 +- nucleus_hipsc_train/41/50551/6022 +- nucleus_hipsc_train/41/53044/15243 +- nucleus_hipsc_train/41/53046/16965 +- nucleus_hipsc_train/41/53428/6238 +- nucleus_hipsc_train/41/53524/15636 +- nucleus_hipsc_train/41/53538/15395 +- nucleus_hipsc_train/41/53731/15920 +- nucleus_hipsc_train/41/55156/6355 +- nucleus_hipsc_train/41/55156/6358 +- nucleus_hipsc_train/41/55158/6324 +- nucleus_hipsc_train/41/55158/6353 +- nucleus_hipsc_train/41/55253/6499 +- nucleus_hipsc_train/41/55256/6482 +- nucleus_hipsc_train/41/55351/6419 +- nucleus_hipsc_train/41/55363/6362 +- nucleus_hipsc_train/41/55925/6584 +- nucleus_hipsc_train/41/56406/6643 +- nucleus_hipsc_train/41/56416/6614 +- nucleus_hipsc_train/41/56418/6626 +- nucleus_hipsc_train/41/56419/6630 +- nucleus_hipsc_train/41/56596/6678 +- nucleus_hipsc_train/41/56896/7720 +- nucleus_hipsc_train/41/57364/6456 +- nucleus_hipsc_train/41/57365/6428 +- nucleus_hipsc_train/41/57367/6430 +- nucleus_hipsc_train/41/57464/6544 +- nucleus_hipsc_train/41/57472/6556 +- nucleus_hipsc_train/41/57472/6565 +- nucleus_hipsc_train/41/58134/6821 +- nucleus_hipsc_train/41/58326/6840 +- nucleus_hipsc_train/41/58420/6971 +- nucleus_hipsc_train/41/58423/6963 +- nucleus_hipsc_train/41/58518/6786 +- nucleus_hipsc_train/41/59285/7118 +- nucleus_hipsc_train/41/59285/7124 +- nucleus_hipsc_train/41/59298/7175 +- nucleus_hipsc_train/41/59380/7015 +- nucleus_hipsc_train/41/59479/7188 +- nucleus_hipsc_train/41/59479/7200 +- nucleus_hipsc_train/41/59480/7179 +- nucleus_hipsc_train/41/60548/7475 +- nucleus_hipsc_train/41/60632/7345 +- nucleus_hipsc_train/41/60726/7399 +- nucleus_hipsc_train/41/60737/7332 +- nucleus_hipsc_train/41/60738/7414 +- nucleus_hipsc_train/41/62740/7068 +- nucleus_hipsc_train/41/62932/6916 +- nucleus_hipsc_train/41/63508/7389 +- nucleus_hipsc_train/41/63523/7383 +- nucleus_hipsc_train/41/63608/7462 +- nucleus_hipsc_train/41/63608/7464 +- nucleus_hipsc_train/41/63620/7451 +- nucleus_hipsc_train/41/63701/7283 +- nucleus_hipsc_train/41/63713/7256 +- nucleus_hipsc_train/41/66292/7775 +- nucleus_hipsc_train/41/66292/7782 +- nucleus_hipsc_train/41/66292/7796 +- nucleus_hipsc_train/41/66296/7788 +- nucleus_hipsc_train/41/67157/7690 +- nucleus_hipsc_train/41/67168/7678 +- nucleus_hipsc_train/41/68131/7834 +- nucleus_hipsc_train/41/68503/9206 +- nucleus_hipsc_train/41/68504/9176 +- nucleus_hipsc_train/41/68504/9197 +- nucleus_hipsc_train/41/68512/9188 +- nucleus_hipsc_train/41/68512/9207 +- nucleus_hipsc_train/41/68512/9212 +- nucleus_hipsc_train/41/68708/9065 +- nucleus_hipsc_train/41/68788/9030 +- nucleus_hipsc_train/41/68800/9019 +- nucleus_hipsc_train/41/69472/9285 +- nucleus_hipsc_train/41/69473/9279 +- nucleus_hipsc_train/41/69474/9306 +- nucleus_hipsc_train/41/70052/15689 +- nucleus_hipsc_train/41/70231/9525 +- nucleus_hipsc_train/41/70232/9551 +- nucleus_hipsc_train/41/72244/8037 +- nucleus_hipsc_train/41/72244/8074 +- nucleus_hipsc_train/41/72256/8049 +- nucleus_hipsc_train/41/72260/8085 +- nucleus_hipsc_train/41/72342/7994 +- nucleus_hipsc_train/41/72356/7962 +- nucleus_hipsc_train/41/72628/8109 +- nucleus_hipsc_train/41/72629/8086 +- nucleus_hipsc_train/41/72630/8119 +- nucleus_hipsc_train/41/72631/8095 +- nucleus_hipsc_train/41/72725/8151 +- nucleus_hipsc_train/41/72726/8128 +- nucleus_hipsc_train/41/72834/8288 +- nucleus_hipsc_train/41/73300/8255 +- nucleus_hipsc_train/41/73396/8265 +- nucleus_hipsc_train/41/73397/8271 +- nucleus_hipsc_train/41/73398/8307 +- nucleus_hipsc_train/41/73495/8186 +- nucleus_hipsc_train/41/73507/8203 +- nucleus_hipsc_train/41/73685/8634 +- nucleus_hipsc_train/41/73687/8628 +- nucleus_hipsc_train/41/73700/8663 +- nucleus_hipsc_train/41/73782/8525 +- nucleus_hipsc_train/41/73782/8576 +- nucleus_hipsc_train/41/73783/8530 +- nucleus_hipsc_train/41/73784/8543 +- nucleus_hipsc_train/41/73879/15995 +- nucleus_hipsc_train/41/73975/15832 +- nucleus_hipsc_train/41/74165/8821 +- nucleus_hipsc_train/41/74168/8793 +- nucleus_hipsc_train/41/74260/8727 +- nucleus_hipsc_train/41/74273/8721 +- nucleus_hipsc_train/41/74371/8941 +- nucleus_hipsc_train/41/74371/8978 +- nucleus_hipsc_train/41/75042/7915 +- nucleus_hipsc_train/41/75124/16978 +- nucleus_hipsc_train/41/75125/16693 +- nucleus_hipsc_train/41/75512/7872 +- nucleus_hipsc_train/41/75796/7941 +- nucleus_hipsc_train/41/75799/7953 +- nucleus_hipsc_train/41/76000/8244 +- nucleus_hipsc_train/41/77250/8868 +- nucleus_hipsc_train/41/77333/9094 +- nucleus_hipsc_train/42/106420/10373 +- nucleus_hipsc_train/42/106421/10380 +- nucleus_hipsc_train/42/106422/10368 +- nucleus_hipsc_train/42/106516/10272 +- nucleus_hipsc_train/42/106518/10239 +- nucleus_hipsc_train/42/106520/10262 +- nucleus_hipsc_train/42/106915/10747 +- nucleus_hipsc_train/42/106996/10652 +- nucleus_hipsc_train/42/106998/10641 +- nucleus_hipsc_train/42/107480/10815 +- nucleus_hipsc_train/42/107480/10822 +- nucleus_hipsc_train/42/107572/12022 +- nucleus_hipsc_train/42/107574/11982 +- nucleus_hipsc_train/42/107574/12039 +- nucleus_hipsc_train/42/107682/11895 +- nucleus_hipsc_train/42/107682/11898 +- nucleus_hipsc_train/42/107684/11928 +- nucleus_hipsc_train/42/107956/11969 +- nucleus_hipsc_train/42/107956/11981 +- nucleus_hipsc_train/42/107958/11911 +- nucleus_hipsc_train/42/107959/12029 +- nucleus_hipsc_train/42/107972/11941 +- nucleus_hipsc_train/42/108148/15673 +- nucleus_hipsc_train/42/108149/12190 +- nucleus_hipsc_train/42/108246/11135 +- nucleus_hipsc_train/42/108248/16355 +- nucleus_hipsc_train/42/108824/15581 +- nucleus_hipsc_train/42/108833/15155 +- nucleus_hipsc_train/42/110548/10130 +- nucleus_hipsc_train/42/110552/10154 +- nucleus_hipsc_train/42/110552/10175 +- nucleus_hipsc_train/42/110645/10108 +- nucleus_hipsc_train/42/110646/10124 +- nucleus_hipsc_train/42/110660/10091 +- nucleus_hipsc_train/42/110947/10199 +- nucleus_hipsc_train/42/111125/10242 +- nucleus_hipsc_train/42/111413/10485 +- nucleus_hipsc_train/42/111415/10486 +- nucleus_hipsc_train/42/111426/10473 +- nucleus_hipsc_train/42/111892/10724 +- nucleus_hipsc_train/42/112084/15061 +- nucleus_hipsc_train/42/112085/16293 +- nucleus_hipsc_train/42/112280/15454 +- nucleus_hipsc_train/42/112565/10904 +- nucleus_hipsc_train/42/112758/16064 +- nucleus_hipsc_train/42/112772/14973 +- nucleus_hipsc_train/42/113432/11852 +- nucleus_hipsc_train/42/113634/10939 +- nucleus_hipsc_train/42/113921/11053 +- nucleus_hipsc_train/42/114209/10977 +- nucleus_hipsc_train/42/114212/10981 +- nucleus_hipsc_train/42/114787/11121 +- nucleus_hipsc_train/42/114788/11097 +- nucleus_hipsc_train/42/114965/11232 +- nucleus_hipsc_train/42/114965/11269 +- nucleus_hipsc_train/42/114979/11222 +- nucleus_hipsc_train/42/115160/12126 +- nucleus_hipsc_train/42/115169/16617 +- nucleus_hipsc_train/42/115349/11410 +- nucleus_hipsc_train/42/115541/15346 +- nucleus_hipsc_train/42/115542/16879 +- nucleus_hipsc_train/42/115552/15185 +- nucleus_hipsc_train/42/115554/15716 +- nucleus_hipsc_train/42/115555/16425 +- nucleus_hipsc_train/42/115556/15703 +- nucleus_hipsc_train/42/115831/11479 +- nucleus_hipsc_train/42/116034/11497 +- nucleus_hipsc_train/42/116309/11595 +- nucleus_hipsc_train/42/116324/11616 +- nucleus_hipsc_train/42/116608/10515 +- nucleus_hipsc_train/42/116608/10614 +- nucleus_hipsc_train/42/116887/10440 +- nucleus_hipsc_train/42/116897/10412 +- nucleus_hipsc_train/42/116900/10422 +- nucleus_hipsc_train/42/117173/10673 +- nucleus_hipsc_train/42/117186/10657 +- nucleus_hipsc_train/42/117557/11347 +- nucleus_hipsc_train/42/117559/11367 +- nucleus_hipsc_train/42/117572/11385 +- nucleus_hipsc_train/42/117847/11299 +- nucleus_hipsc_train/42/118420/11731 +- nucleus_hipsc_train/42/118423/11658 +- nucleus_hipsc_train/42/118712/11569 +- nucleus_hipsc_train/42/118806/11804 +- nucleus_hipsc_train/42/118808/11800 +- nucleus_hipsc_train/42/121791/16666 +- nucleus_hipsc_train/42/121793/15852 +- nucleus_hipsc_train/42/121806/15946 +- nucleus_hipsc_train/42/123328/15550 +- nucleus_hipsc_train/42/123328/17092 +- nucleus_hipsc_train/42/123714/16851 +- nucleus_hipsc_train/42/123903/15431 +- nucleus_hipsc_train/42/124002/16132 +- nucleus_hipsc_train/42/124014/16885 +- nucleus_hipsc_train/42/124205/15565 +- nucleus_hipsc_train/42/124287/15382 +- nucleus_hipsc_train/42/124290/15483 +- nucleus_hipsc_train/42/124291/15731 +- nucleus_hipsc_train/42/124299/16712 +- nucleus_hipsc_train/42/124301/15843 +- nucleus_hipsc_train/42/127171/12333 +- nucleus_hipsc_train/42/127647/12252 +- nucleus_hipsc_train/42/127648/12223 +- nucleus_hipsc_train/42/127649/12208 +- nucleus_hipsc_train/42/127650/12238 +- nucleus_hipsc_train/42/127650/12256 +- nucleus_hipsc_train/42/127651/12217 +- nucleus_hipsc_train/42/127651/12239 +- nucleus_hipsc_train/42/127852/12320 +- nucleus_hipsc_train/42/127935/12457 +- nucleus_hipsc_train/42/127947/12485 +- nucleus_hipsc_train/42/128416/12512 +- nucleus_hipsc_train/42/128514/12657 +- nucleus_hipsc_train/42/128514/12667 +- nucleus_hipsc_train/42/128525/12654 +- nucleus_hipsc_train/42/128715/12598 +- nucleus_hipsc_train/42/128718/12626 +- nucleus_hipsc_train/42/128719/12625 +- nucleus_hipsc_train/42/129473/12830 +- nucleus_hipsc_train/42/129473/12852 +- nucleus_hipsc_train/42/129571/12811 +- nucleus_hipsc_train/42/129583/12802 +- nucleus_hipsc_train/42/129774/12715 +- nucleus_hipsc_train/42/129855/12931 +- nucleus_hipsc_train/42/130155/13043 +- nucleus_hipsc_train/42/130527/12960 +- nucleus_hipsc_train/42/130625/16186 +- nucleus_hipsc_train/42/130707/13231 +- nucleus_hipsc_train/42/130722/17097 +- nucleus_hipsc_train/42/132173/13409 +- nucleus_hipsc_train/42/132175/13365 +- nucleus_hipsc_train/42/132653/13278 +- nucleus_hipsc_train/42/132831/13415 +- nucleus_hipsc_train/42/132844/13432 +- nucleus_hipsc_train/42/132845/13448 +- nucleus_hipsc_train/42/132929/13513 +- nucleus_hipsc_train/42/133133/13640 +- nucleus_hipsc_train/42/133323/13465 +- nucleus_hipsc_train/42/133324/13457 +- nucleus_hipsc_train/42/133325/13497 +- nucleus_hipsc_train/42/133503/13577 +- nucleus_hipsc_train/42/133504/13572 +- nucleus_hipsc_train/42/133602/13711 +- nucleus_hipsc_train/42/133711/13788 +- nucleus_hipsc_train/42/134272/13918 +- nucleus_hipsc_train/42/134286/13916 +- nucleus_hipsc_train/42/134656/13884 +- nucleus_hipsc_train/42/135272/14059 +- nucleus_hipsc_train/42/135440/14128 +- nucleus_hipsc_train/42/135525/14245 +- nucleus_hipsc_train/42/135614/14178 +- nucleus_hipsc_train/42/137434/14771 +- nucleus_hipsc_train/42/137464/14708 +- nucleus_hipsc_train/42/137767/14413 +- nucleus_hipsc_train/42/137772/14516 +- nucleus_hipsc_train/42/137956/15501 +- nucleus_hipsc_train/42/137956/16613 +- nucleus_hipsc_train/42/137956/17196 +- nucleus_hipsc_train/42/137956/17224 +- nucleus_hipsc_train/42/138024/15890 +- nucleus_hipsc_train/42/138028/16174 +- nucleus_hipsc_train/42/138032/15577 +- nucleus_hipsc_train/42/138261/16083 +- nucleus_hipsc_train/42/77912/9479 +- nucleus_hipsc_train/42/77912/9520 +- nucleus_hipsc_train/42/77923/9543 +- nucleus_hipsc_train/42/78389/9675 +- nucleus_hipsc_train/42/78391/9672 +- nucleus_hipsc_train/42/78487/9750 +- nucleus_hipsc_train/42/78487/9758 +- nucleus_hipsc_train/42/78691/9802 +- nucleus_hipsc_train/42/79541/9897 +- nucleus_hipsc_train/42/79552/9894 +- nucleus_hipsc_train/42/79554/9874 +- nucleus_hipsc_train/42/79828/9972 +- nucleus_hipsc_train/42/79831/9969 +- nucleus_hipsc_train/42/79832/9978 +- nucleus_hipsc_train/42/79841/9963 +- nucleus_hipsc_train/42/80023/15006 +- nucleus_hipsc_train/42/80033/15189 +- nucleus_hipsc_train/42/80035/9980 +- nucleus_hipsc_train/42/80224/9960 +- nucleus_hipsc_train/42/83392/9630 +- h2b_a549_mantis_2026_03_26_train/B/2/000002 +- h2b_a549_mantis_2026_03_26_train/B/2/000003 +- h2b_a549_mantis_2026_03_26_train/B/2/000005 +- h2b_a549_mantis_2026_03_26_train/B/2/000006 +- h2b_a549_mantis_2026_03_26_train/B/2/000008 +- h2b_a549_mantis_2026_03_26_train/B/2/001000 +- h2b_a549_mantis_2026_03_26_train/B/2/001001 +- h2b_a549_mantis_2026_03_26_train/B/2/001002 +- h2b_a549_mantis_2026_03_26_train/B/2/001003 +- h2b_a549_mantis_2026_03_26_train/B/2/001004 +- h2b_a549_mantis_2026_03_26_train/B/2/001005 +- h2b_a549_mantis_2026_03_26_train/B/2/001006 +- h2b_a549_mantis_2026_03_26_train/B/2/001007 +- h2b_a549_mantis_2026_03_26_train/B/2/001008 +- h2b_a549_mantis_2026_03_26_train/B/2/002000 +- h2b_a549_mantis_2026_03_26_train/B/2/002001 +- h2b_a549_mantis_2026_03_26_train/B/2/002002 +- h2b_a549_mantis_2026_03_26_train/B/2/002003 +- h2b_a549_mantis_2026_03_26_train/B/2/002004 +- h2b_a549_mantis_2026_03_26_train/B/2/002005 +- h2b_a549_mantis_2026_03_26_train/B/2/002006 +- h2b_a549_mantis_2026_03_26_train/B/2/002007 +- h2b_a549_mantis_2026_03_26_train/B/2/002008 +- h2b_a549_mantis_2026_03_26_train/B/2/003000 +- h2b_a549_mantis_2026_03_26_train/B/2/003002 +- h2b_a549_mantis_2026_03_26_train/B/2/003003 +- h2b_a549_mantis_2026_03_26_train/B/2/003005 +- h2b_a549_mantis_2026_03_26_train/B/2/003006 +- h2b_a549_mantis_2026_03_26_train/B/2/003008 +- h2b_a549_mantis_2026_03_26_train/B/2/004000 +- h2b_a549_mantis_2026_03_26_train/B/2/004001 +- h2b_a549_mantis_2026_03_26_train/B/2/004002 +- h2b_a549_mantis_2026_03_26_train/B/2/004003 +- h2b_a549_mantis_2026_03_26_train/B/2/004004 +- h2b_a549_mantis_2026_03_26_train/B/2/004005 +- h2b_a549_mantis_2026_03_26_train/B/2/004006 +- h2b_a549_mantis_2026_03_26_train/B/2/004007 +- h2b_a549_mantis_2026_03_26_train/B/2/004008 +- h2b_a549_mantis_2026_03_26_train/B/2/005000 +- h2b_a549_mantis_2026_03_26_train/B/2/005002 +- h2b_a549_mantis_2026_03_26_train/B/2/005003 +- h2b_a549_mantis_2026_03_26_train/B/2/005005 +- h2b_a549_mantis_2026_03_26_train/B/2/005006 +- h2b_a549_mantis_2026_03_26_train/B/2/005008 +- h2b_a549_mantis_2026_03_26_train/B/2/006000 +- h2b_a549_mantis_2026_03_26_train/B/2/006001 +- h2b_a549_mantis_2026_03_26_train/B/2/006002 +- h2b_a549_mantis_2026_03_26_train/B/2/006003 +- h2b_a549_mantis_2026_03_26_train/B/2/006004 +- h2b_a549_mantis_2026_03_26_train/B/2/006005 +- h2b_a549_mantis_2026_03_26_train/B/2/006006 +- h2b_a549_mantis_2026_03_26_train/B/2/006007 +- h2b_a549_mantis_2026_03_26_train/B/2/006008 +- h2b_a549_mantis_2026_03_26_train/B/2/007000 +- h2b_a549_mantis_2026_03_26_train/B/2/007001 +- h2b_a549_mantis_2026_03_26_train/B/2/007002 +- h2b_a549_mantis_2026_03_26_train/B/2/007003 +- h2b_a549_mantis_2026_03_26_train/B/2/007004 +- h2b_a549_mantis_2026_03_26_train/B/2/007005 +- h2b_a549_mantis_2026_03_26_train/B/2/007006 +- h2b_a549_mantis_2026_03_26_train/B/2/007007 +- h2b_a549_mantis_2026_03_26_train/B/2/007008 +- h2b_a549_mantis_2026_03_26_train/B/2/008000 +- h2b_a549_mantis_2026_03_26_train/B/2/008002 +- h2b_a549_mantis_2026_03_26_train/B/2/008003 +- h2b_a549_mantis_2026_03_26_train/B/2/008005 +- h2b_a549_mantis_2026_03_26_train/B/2/008006 +- h2b_a549_mantis_2026_03_26_train/B/2/008008 +- h2b_a549_mantis_2026_03_26_train/B/3/000000 +- h2b_a549_mantis_2026_03_26_train/B/3/000002 +- h2b_a549_mantis_2026_03_26_train/B/3/000003 +- h2b_a549_mantis_2026_03_26_train/B/3/000005 +- h2b_a549_mantis_2026_03_26_train/B/3/000006 +- h2b_a549_mantis_2026_03_26_train/B/3/000008 +- h2b_a549_mantis_2026_03_26_train/B/3/001000 +- h2b_a549_mantis_2026_03_26_train/B/3/001001 +- h2b_a549_mantis_2026_03_26_train/B/3/001002 +- h2b_a549_mantis_2026_03_26_train/B/3/001003 +- h2b_a549_mantis_2026_03_26_train/B/3/001004 +- h2b_a549_mantis_2026_03_26_train/B/3/001005 +- h2b_a549_mantis_2026_03_26_train/B/3/001006 +- h2b_a549_mantis_2026_03_26_train/B/3/001007 +- h2b_a549_mantis_2026_03_26_train/B/3/001008 +- h2b_a549_mantis_2026_03_26_train/B/3/002000 +- h2b_a549_mantis_2026_03_26_train/B/3/002001 +- h2b_a549_mantis_2026_03_26_train/B/3/002002 +- h2b_a549_mantis_2026_03_26_train/B/3/002003 +- h2b_a549_mantis_2026_03_26_train/B/3/002004 +- h2b_a549_mantis_2026_03_26_train/B/3/002005 +- h2b_a549_mantis_2026_03_26_train/B/3/002006 +- h2b_a549_mantis_2026_03_26_train/B/3/002007 +- h2b_a549_mantis_2026_03_26_train/B/3/002008 +- h2b_a549_mantis_2026_03_26_train/B/3/003000 +- h2b_a549_mantis_2026_03_26_train/B/3/003002 +- h2b_a549_mantis_2026_03_26_train/B/3/003003 +- h2b_a549_mantis_2026_03_26_train/B/3/003005 +- h2b_a549_mantis_2026_03_26_train/B/3/003006 +- h2b_a549_mantis_2026_03_26_train/B/3/003008 +- h2b_a549_mantis_2026_03_26_train/B/3/004000 +- h2b_a549_mantis_2026_03_26_train/B/3/004001 +- h2b_a549_mantis_2026_03_26_train/B/3/004002 +- h2b_a549_mantis_2026_03_26_train/B/3/004003 +- h2b_a549_mantis_2026_03_26_train/B/3/004004 +- h2b_a549_mantis_2026_03_26_train/B/3/004005 +- h2b_a549_mantis_2026_03_26_train/B/3/004006 +- h2b_a549_mantis_2026_03_26_train/B/3/004007 +- h2b_a549_mantis_2026_03_26_train/B/3/004008 +- h2b_a549_mantis_2026_03_26_train/B/3/005000 +- h2b_a549_mantis_2026_03_26_train/B/3/005002 +- h2b_a549_mantis_2026_03_26_train/B/3/005003 +- h2b_a549_mantis_2026_03_26_train/B/3/005005 +- h2b_a549_mantis_2026_03_26_train/B/3/005006 +- h2b_a549_mantis_2026_03_26_train/B/3/005008 +- h2b_a549_mantis_2026_03_26_train/B/3/006000 +- h2b_a549_mantis_2026_03_26_train/B/3/006001 +- h2b_a549_mantis_2026_03_26_train/B/3/006002 +- h2b_a549_mantis_2026_03_26_train/B/3/006003 +- h2b_a549_mantis_2026_03_26_train/B/3/006004 +- h2b_a549_mantis_2026_03_26_train/B/3/006005 +- h2b_a549_mantis_2026_03_26_train/B/3/006006 +- h2b_a549_mantis_2026_03_26_train/B/3/006007 +- h2b_a549_mantis_2026_03_26_train/B/3/006008 +- h2b_a549_mantis_2026_03_26_train/B/3/007000 +- h2b_a549_mantis_2026_03_26_train/B/3/007001 +- h2b_a549_mantis_2026_03_26_train/B/3/007002 +- h2b_a549_mantis_2026_03_26_train/B/3/007003 +- h2b_a549_mantis_2026_03_26_train/B/3/007004 +- h2b_a549_mantis_2026_03_26_train/B/3/007005 +- h2b_a549_mantis_2026_03_26_train/B/3/007006 +- h2b_a549_mantis_2026_03_26_train/B/3/007007 +- h2b_a549_mantis_2026_03_26_train/B/3/007008 +- h2b_a549_mantis_2026_03_26_train/B/3/008000 +- h2b_a549_mantis_2026_03_26_train/B/3/008002 +- h2b_a549_mantis_2026_03_26_train/B/3/008003 +- h2b_a549_mantis_2026_03_26_train/B/3/008005 +- h2b_a549_mantis_2026_03_26_train/B/3/008006 +- h2b_a549_mantis_2026_03_26_train/B/3/008008 +- h2b_a549_mantis_2026_03_26_train/B/4/000000 +- h2b_a549_mantis_2026_03_26_train/B/4/000002 +- h2b_a549_mantis_2026_03_26_train/B/4/000003 +- h2b_a549_mantis_2026_03_26_train/B/4/000005 +- h2b_a549_mantis_2026_03_26_train/B/4/000006 +- h2b_a549_mantis_2026_03_26_train/B/4/000008 +- h2b_a549_mantis_2026_03_26_train/B/4/001000 +- h2b_a549_mantis_2026_03_26_train/B/4/001001 +- h2b_a549_mantis_2026_03_26_train/B/4/001002 +- h2b_a549_mantis_2026_03_26_train/B/4/001003 +- h2b_a549_mantis_2026_03_26_train/B/4/001004 +- h2b_a549_mantis_2026_03_26_train/B/4/001005 +- h2b_a549_mantis_2026_03_26_train/B/4/001006 +- h2b_a549_mantis_2026_03_26_train/B/4/001007 +- h2b_a549_mantis_2026_03_26_train/B/4/001008 +- h2b_a549_mantis_2026_03_26_train/B/4/002000 +- h2b_a549_mantis_2026_03_26_train/B/4/002001 +- h2b_a549_mantis_2026_03_26_train/B/4/002002 +- h2b_a549_mantis_2026_03_26_train/B/4/002003 +- h2b_a549_mantis_2026_03_26_train/B/4/002004 +- h2b_a549_mantis_2026_03_26_train/B/4/002005 +- h2b_a549_mantis_2026_03_26_train/B/4/002006 +- h2b_a549_mantis_2026_03_26_train/B/4/002007 +- h2b_a549_mantis_2026_03_26_train/B/4/002008 +- h2b_a549_mantis_2026_03_26_train/B/4/003000 +- h2b_a549_mantis_2026_03_26_train/B/4/003002 +- h2b_a549_mantis_2026_03_26_train/B/4/003003 +- h2b_a549_mantis_2026_03_26_train/B/4/003005 +- h2b_a549_mantis_2026_03_26_train/B/4/003006 +- h2b_a549_mantis_2026_03_26_train/B/4/003008 +- h2b_a549_mantis_2026_03_26_train/B/4/004000 +- h2b_a549_mantis_2026_03_26_train/B/4/004001 +- h2b_a549_mantis_2026_03_26_train/B/4/004002 +- h2b_a549_mantis_2026_03_26_train/B/4/004003 +- h2b_a549_mantis_2026_03_26_train/B/4/004004 +- h2b_a549_mantis_2026_03_26_train/B/4/004005 +- h2b_a549_mantis_2026_03_26_train/B/4/004006 +- h2b_a549_mantis_2026_03_26_train/B/4/004007 +- h2b_a549_mantis_2026_03_26_train/B/4/004008 +- h2b_a549_mantis_2026_03_26_train/B/4/005000 +- h2b_a549_mantis_2026_03_26_train/B/4/005002 +- h2b_a549_mantis_2026_03_26_train/B/4/005003 +- h2b_a549_mantis_2026_03_26_train/B/4/005005 +- h2b_a549_mantis_2026_03_26_train/B/4/005006 +- h2b_a549_mantis_2026_03_26_train/B/4/005008 +- h2b_a549_mantis_2026_03_26_train/B/4/006000 +- h2b_a549_mantis_2026_03_26_train/B/4/006001 +- h2b_a549_mantis_2026_03_26_train/B/4/006002 +- h2b_a549_mantis_2026_03_26_train/B/4/006003 +- h2b_a549_mantis_2026_03_26_train/B/4/006004 +- h2b_a549_mantis_2026_03_26_train/B/4/006005 +- h2b_a549_mantis_2026_03_26_train/B/4/006006 +- h2b_a549_mantis_2026_03_26_train/B/4/006007 +- h2b_a549_mantis_2026_03_26_train/B/4/006008 +- h2b_a549_mantis_2026_03_26_train/B/4/007000 +- h2b_a549_mantis_2026_03_26_train/B/4/007001 +- h2b_a549_mantis_2026_03_26_train/B/4/007002 +- h2b_a549_mantis_2026_03_26_train/B/4/007003 +- h2b_a549_mantis_2026_03_26_train/B/4/007004 +- h2b_a549_mantis_2026_03_26_train/B/4/007005 +- h2b_a549_mantis_2026_03_26_train/B/4/007006 +- h2b_a549_mantis_2026_03_26_train/B/4/007007 +- h2b_a549_mantis_2026_03_26_train/B/4/007008 +- h2b_a549_mantis_2026_03_26_train/B/4/008000 +- h2b_a549_mantis_2026_03_26_train/B/4/008002 +- h2b_a549_mantis_2026_03_26_train/B/4/008003 +- h2b_a549_mantis_2026_03_26_train/B/4/008005 +- h2b_a549_mantis_2026_03_26_train/B/4/008006 +- h2b_a549_mantis_2026_03_26_train/B/4/008008 +test_fovs: +- nucleus_hipsc_test/4/11393/1428 +- nucleus_hipsc_test/4/11479/1481 +- nucleus_hipsc_test/4/18007/1641 +- nucleus_hipsc_test/4/18102/1710 +- nucleus_hipsc_test/4/18485/1842 +- nucleus_hipsc_test/4/22901/3306 +- nucleus_hipsc_test/4/27797/2857 +- nucleus_hipsc_test/4/28759/3400 +- nucleus_hipsc_test/4/29060/3786 +- nucleus_hipsc_test/4/29140/3687 +- nucleus_hipsc_test/4/29334/3890 +- nucleus_hipsc_test/4/30293/3915 +- nucleus_hipsc_test/4/31736/15232 +- nucleus_hipsc_test/4/32024/4089 +- nucleus_hipsc_test/4/34998/4271 +- nucleus_hipsc_test/4/35284/4501 +- nucleus_hipsc_test/4/36643/4930 +- nucleus_hipsc_test/4/37601/5175 +- nucleus_hipsc_test/4/38464/5176 +- nucleus_hipsc_test/4/4556/15828 +- nucleus_hipsc_test/4/4556/16242 +- nucleus_hipsc_test/4/5910/824 +- nucleus_hipsc_test/4/6497/1014 +- nucleus_hipsc_test/4/6775/1242 +- nucleus_hipsc_test/4/8706/1138 +- nucleus_hipsc_test/4/94507/699 +- nucleus_hipsc_test/41/44212/5751 +- nucleus_hipsc_test/41/48436/5515 +- nucleus_hipsc_test/41/48536/5593 +- nucleus_hipsc_test/41/49121/5716 +- nucleus_hipsc_test/41/49121/5777 +- nucleus_hipsc_test/41/49204/5680 +- nucleus_hipsc_test/41/49888/5888 +- nucleus_hipsc_test/41/49975/5926 +- nucleus_hipsc_test/41/50548/6016 +- nucleus_hipsc_test/41/52564/5966 +- nucleus_hipsc_test/41/53048/15203 +- nucleus_hipsc_test/41/55160/6367 +- nucleus_hipsc_test/41/55348/6437 +- nucleus_hipsc_test/41/55350/6427 +- nucleus_hipsc_test/41/58326/6874 +- nucleus_hipsc_test/41/58517/6781 +- nucleus_hipsc_test/41/60728/7413 +- nucleus_hipsc_test/41/62754/7076 +- nucleus_hipsc_test/41/63524/7359 +- nucleus_hipsc_test/41/63524/7400 +- nucleus_hipsc_test/41/63713/7287 +- nucleus_hipsc_test/41/66020/7541 +- nucleus_hipsc_test/41/67168/7688 +- nucleus_hipsc_test/41/68116/7831 +- nucleus_hipsc_test/41/68598/9132 +- nucleus_hipsc_test/41/68804/8999 +- nucleus_hipsc_test/41/68884/9247 +- nucleus_hipsc_test/41/68885/9316 +- nucleus_hipsc_test/41/70240/9487 +- nucleus_hipsc_test/41/72356/7974 +- nucleus_hipsc_test/41/72629/8071 +- nucleus_hipsc_test/41/72725/8138 +- nucleus_hipsc_test/41/72727/8125 +- nucleus_hipsc_test/41/73112/8476 +- nucleus_hipsc_test/41/73304/8259 +- nucleus_hipsc_test/41/73686/8660 +- nucleus_hipsc_test/41/73686/8668 +- nucleus_hipsc_test/41/73783/8567 +- nucleus_hipsc_test/41/74264/8751 +- nucleus_hipsc_test/41/74272/8740 +- nucleus_hipsc_test/41/74356/8919 +- nucleus_hipsc_test/41/75800/8019 +- nucleus_hipsc_test/41/75808/7975 +- nucleus_hipsc_test/42/107478/10817 +- nucleus_hipsc_test/42/114584/12053 +- nucleus_hipsc_test/42/115556/15421 +- nucleus_hipsc_test/42/116598/10604 +- nucleus_hipsc_test/42/117557/11343 +- nucleus_hipsc_test/42/118901/11674 +- nucleus_hipsc_test/42/118912/11694 +- nucleus_hipsc_test/42/123916/16655 +- nucleus_hipsc_test/42/124001/16229 +- nucleus_hipsc_test/42/127171/12338 +- nucleus_hipsc_test/42/127276/23725 +- nucleus_hipsc_test/42/127939/12482 +- nucleus_hipsc_test/42/128428/12536 +- nucleus_hipsc_test/42/128523/12637 +- nucleus_hipsc_test/42/129665/12780 +- nucleus_hipsc_test/42/129855/12890 +- nucleus_hipsc_test/42/132463/13304 +- nucleus_hipsc_test/42/132834/13446 +- nucleus_hipsc_test/42/133599/13746 +- nucleus_hipsc_test/42/135439/14132 +- nucleus_hipsc_test/42/137449/14744 +- nucleus_hipsc_test/42/137455/14731 +- nucleus_hipsc_test/42/137460/14685 +- nucleus_hipsc_test/42/137582/14642 +- nucleus_hipsc_test/42/137774/14522 +- nucleus_hipsc_test/42/137820/14488 +- nucleus_hipsc_test/42/137953/15518 +- nucleus_hipsc_test/42/77924/9512 +- nucleus_hipsc_test/42/80023/9994 +- nucleus_hipsc_test/42/82708/16181 +- nucleus_hipsc_test/42/84449/15422 +- h2b_a549_mantis_2026_03_26_test/B/2/000001 +- h2b_a549_mantis_2026_03_26_test/B/2/000004 +- h2b_a549_mantis_2026_03_26_test/B/2/000007 +- h2b_a549_mantis_2026_03_26_test/B/2/003001 +- h2b_a549_mantis_2026_03_26_test/B/2/003004 +- h2b_a549_mantis_2026_03_26_test/B/2/003007 +- h2b_a549_mantis_2026_03_26_test/B/2/005001 +- h2b_a549_mantis_2026_03_26_test/B/2/005004 +- h2b_a549_mantis_2026_03_26_test/B/2/005007 +- h2b_a549_mantis_2026_03_26_test/B/2/008001 +- h2b_a549_mantis_2026_03_26_test/B/2/008004 +- h2b_a549_mantis_2026_03_26_test/B/2/008007 +- h2b_a549_mantis_2026_03_26_test/B/3/000001 +- h2b_a549_mantis_2026_03_26_test/B/3/000004 +- h2b_a549_mantis_2026_03_26_test/B/3/000007 +- h2b_a549_mantis_2026_03_26_test/B/3/003001 +- h2b_a549_mantis_2026_03_26_test/B/3/003004 +- h2b_a549_mantis_2026_03_26_test/B/3/003007 +- h2b_a549_mantis_2026_03_26_test/B/3/005001 +- h2b_a549_mantis_2026_03_26_test/B/3/005004 +- h2b_a549_mantis_2026_03_26_test/B/3/005007 +- h2b_a549_mantis_2026_03_26_test/B/3/008001 +- h2b_a549_mantis_2026_03_26_test/B/3/008004 +- h2b_a549_mantis_2026_03_26_test/B/3/008007 +- h2b_a549_mantis_2026_03_26_test/B/4/000001 +- h2b_a549_mantis_2026_03_26_test/B/4/000004 +- h2b_a549_mantis_2026_03_26_test/B/4/000007 +- h2b_a549_mantis_2026_03_26_test/B/4/003001 +- h2b_a549_mantis_2026_03_26_test/B/4/003004 +- h2b_a549_mantis_2026_03_26_test/B/4/003007 +- h2b_a549_mantis_2026_03_26_test/B/4/005001 +- h2b_a549_mantis_2026_03_26_test/B/4/005004 +- h2b_a549_mantis_2026_03_26_test/B/4/005007 +- h2b_a549_mantis_2026_03_26_test/B/4/008001 +- h2b_a549_mantis_2026_03_26_test/B/4/008004 +- h2b_a549_mantis_2026_03_26_test/B/4/008007 diff --git a/applications/dynacell/configs/collections/virtual_staining/nucleus_joint_mock_v1.yaml b/applications/dynacell/configs/collections/virtual_staining/nucleus_joint_mock_v1.yaml new file mode 100644 index 000000000..bfeb2ac6f --- /dev/null +++ b/applications/dynacell/configs/collections/virtual_staining/nucleus_joint_mock_v1.yaml @@ -0,0 +1,779 @@ +name: nucleus_joint_mock_v1 +description: Joint frozen benchmark collection with condition filter 'mock' across + 2 selectors covering targets 'h2b', 'nucleus'. Channels and FOV membership captured + from the live train/test zarr stores at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-27T12:02:53.337464+00:00' + created_by: Alex Kalinin +experiments: +- name: nucleus_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Nuclei + organelle: nucleus + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: nucleus_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Nuclei + organelle: nucleus + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: h2b_a549_mantis_2026_03_26_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2026_03_26_A549_CAAX_H2B_DENV_ZIKV/train/H2B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: H2B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: H2B + organelle: nucleus + pixel_size_xy_um: 0.116 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: h2b_a549_mantis_2026_03_26_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2026_03_26_A549_CAAX_H2B_DENV_ZIKV/test/H2B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: H2B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: H2B + organelle: nucleus + pixel_size_xy_um: 0.116 + pixel_size_z_um: 0.174 + exclude_fovs: [] +train_fovs: +- nucleus_hipsc_train/4/10615/1304 +- nucleus_hipsc_train/4/10625/1347 +- nucleus_hipsc_train/4/10900/1427 +- nucleus_hipsc_train/4/10904/1436 +- nucleus_hipsc_train/4/11384/1404 +- nucleus_hipsc_train/4/11478/1468 +- nucleus_hipsc_train/4/11490/1466 +- nucleus_hipsc_train/4/11492/1467 +- nucleus_hipsc_train/4/11573/1414 +- nucleus_hipsc_train/4/136707/16750 +- nucleus_hipsc_train/4/136710/15363 +- nucleus_hipsc_train/4/136721/16107 +- nucleus_hipsc_train/4/136725/15834 +- nucleus_hipsc_train/4/13974/1528 +- nucleus_hipsc_train/4/14646/1871 +- nucleus_hipsc_train/4/14740/1745 +- nucleus_hipsc_train/4/14742/1791 +- nucleus_hipsc_train/4/14754/1781 +- nucleus_hipsc_train/4/1493/268 +- nucleus_hipsc_train/4/1508/255 +- nucleus_hipsc_train/4/16278/2186 +- nucleus_hipsc_train/4/16376/2374 +- nucleus_hipsc_train/4/16468/2321 +- nucleus_hipsc_train/4/16469/2337 +- nucleus_hipsc_train/4/16469/2339 +- nucleus_hipsc_train/4/16469/2345 +- nucleus_hipsc_train/4/16471/2265 +- nucleus_hipsc_train/4/16472/2312 +- nucleus_hipsc_train/4/16951/2459 +- nucleus_hipsc_train/4/16951/2480 +- nucleus_hipsc_train/4/16952/2494 +- nucleus_hipsc_train/4/17333/2710 +- nucleus_hipsc_train/4/17348/16148 +- nucleus_hipsc_train/4/17525/2811 +- nucleus_hipsc_train/4/17526/2752 +- nucleus_hipsc_train/4/17536/2773 +- nucleus_hipsc_train/4/18020/1618 +- nucleus_hipsc_train/4/18020/1625 +- nucleus_hipsc_train/4/18020/1638 +- nucleus_hipsc_train/4/18487/1811 +- nucleus_hipsc_train/4/19351/1905 +- nucleus_hipsc_train/4/19543/2105 +- nucleus_hipsc_train/4/19554/2020 +- nucleus_hipsc_train/4/19556/2089 +- nucleus_hipsc_train/4/20416/2223 +- nucleus_hipsc_train/4/20596/2406 +- nucleus_hipsc_train/4/20597/2395 +- nucleus_hipsc_train/4/20597/2401 +- nucleus_hipsc_train/4/20599/2373 +- nucleus_hipsc_train/4/21077/2254 +- nucleus_hipsc_train/4/21089/2293 +- nucleus_hipsc_train/4/21556/2491 +- nucleus_hipsc_train/4/21557/2483 +- nucleus_hipsc_train/4/21557/2527 +- nucleus_hipsc_train/4/21653/2547 +- nucleus_hipsc_train/4/21860/15671 +- nucleus_hipsc_train/4/21940/2736 +- nucleus_hipsc_train/4/21943/2717 +- nucleus_hipsc_train/4/21953/2739 +- nucleus_hipsc_train/4/22133/2826 +- nucleus_hipsc_train/4/22136/2827 +- nucleus_hipsc_train/4/22339/3095 +- nucleus_hipsc_train/4/22340/3097 +- nucleus_hipsc_train/4/22612/2915 +- nucleus_hipsc_train/4/22614/2923 +- nucleus_hipsc_train/4/22615/2978 +- nucleus_hipsc_train/4/22624/2909 +- nucleus_hipsc_train/4/22709/3070 +- nucleus_hipsc_train/4/22712/3090 +- nucleus_hipsc_train/4/22913/3301 +- nucleus_hipsc_train/4/22914/3289 +- nucleus_hipsc_train/4/23380/3237 +- nucleus_hipsc_train/4/23392/3212 +- nucleus_hipsc_train/4/23395/3223 +- nucleus_hipsc_train/4/23574/3492 +- nucleus_hipsc_train/4/23764/3409 +- nucleus_hipsc_train/4/24152/3567 +- nucleus_hipsc_train/4/24724/3661 +- nucleus_hipsc_train/4/24727/3659 +- nucleus_hipsc_train/4/24928/3585 +- nucleus_hipsc_train/4/25784/3851 +- nucleus_hipsc_train/4/27800/2883 +- nucleus_hipsc_train/4/27896/2943 +- nucleus_hipsc_train/4/27992/3020 +- nucleus_hipsc_train/4/28084/3214 +- nucleus_hipsc_train/4/28084/3270 +- nucleus_hipsc_train/4/28087/3266 +- nucleus_hipsc_train/4/28756/3381 +- nucleus_hipsc_train/4/28759/3393 +- nucleus_hipsc_train/4/29045/3764 +- nucleus_hipsc_train/4/29060/3753 +- nucleus_hipsc_train/4/29143/3667 +- nucleus_hipsc_train/4/29155/3710 +- nucleus_hipsc_train/4/2932/230 +- nucleus_hipsc_train/4/29333/3908 +- nucleus_hipsc_train/4/2945/173 +- nucleus_hipsc_train/4/30292/14379 +- nucleus_hipsc_train/4/30293/3905 +- nucleus_hipsc_train/4/30308/3869 +- nucleus_hipsc_train/4/30388/16862 +- nucleus_hipsc_train/4/30389/15342 +- nucleus_hipsc_train/4/30392/16741 +- nucleus_hipsc_train/4/31732/17059 +- nucleus_hipsc_train/4/31744/16779 +- nucleus_hipsc_train/4/31841/3962 +- nucleus_hipsc_train/4/31939/3975 +- nucleus_hipsc_train/4/32024/4077 +- nucleus_hipsc_train/4/32033/4111 +- nucleus_hipsc_train/4/32033/4121 +- nucleus_hipsc_train/4/32035/4099 +- nucleus_hipsc_train/4/33077/4379 +- nucleus_hipsc_train/4/33572/4229 +- nucleus_hipsc_train/4/33942/15337 +- nucleus_hipsc_train/4/33942/16205 +- nucleus_hipsc_train/4/33943/17061 +- nucleus_hipsc_train/4/33953/16561 +- nucleus_hipsc_train/4/33955/16023 +- nucleus_hipsc_train/4/34038/4363 +- nucleus_hipsc_train/4/34808/4417 +- nucleus_hipsc_train/4/35000/4274 +- nucleus_hipsc_train/4/35284/4472 +- nucleus_hipsc_train/4/35287/4460 +- nucleus_hipsc_train/4/35479/4551 +- nucleus_hipsc_train/4/35489/4583 +- nucleus_hipsc_train/4/36449/15327 +- nucleus_hipsc_train/4/36544/4909 +- nucleus_hipsc_train/4/36544/4931 +- nucleus_hipsc_train/4/36628/4907 +- nucleus_hipsc_train/4/36836/4996 +- nucleus_hipsc_train/4/37591/5133 +- nucleus_hipsc_train/4/37603/5147 +- nucleus_hipsc_train/4/37972/5388 +- nucleus_hipsc_train/4/37988/5373 +- nucleus_hipsc_train/4/40084/5359 +- nucleus_hipsc_train/4/40086/5362 +- nucleus_hipsc_train/4/40376/4584 +- nucleus_hipsc_train/4/40385/4614 +- nucleus_hipsc_train/4/40386/4613 +- nucleus_hipsc_train/4/40387/4586 +- nucleus_hipsc_train/4/40483/4619 +- nucleus_hipsc_train/4/40483/4621 +- nucleus_hipsc_train/4/40960/4654 +- nucleus_hipsc_train/4/41044/4851 +- nucleus_hipsc_train/4/41047/4885 +- nucleus_hipsc_train/4/41237/4861 +- nucleus_hipsc_train/4/41249/4835 +- nucleus_hipsc_train/4/41912/5074 +- nucleus_hipsc_train/4/5143/954 +- nucleus_hipsc_train/4/5236/869 +- nucleus_hipsc_train/4/5238/875 +- nucleus_hipsc_train/4/6485/1018 +- nucleus_hipsc_train/4/6486/992 +- nucleus_hipsc_train/4/6497/1003 +- nucleus_hipsc_train/4/6775/1203 +- nucleus_hipsc_train/4/6775/1226 +- nucleus_hipsc_train/4/6775/1236 +- nucleus_hipsc_train/4/7156/1124 +- nucleus_hipsc_train/4/7349/1355 +- nucleus_hipsc_train/4/7650/1278 +- nucleus_hipsc_train/4/8214/878 +- nucleus_hipsc_train/4/8214/879 +- nucleus_hipsc_train/4/8228/898 +- nucleus_hipsc_train/4/8695/1215 +- nucleus_hipsc_train/4/88267/15294 +- nucleus_hipsc_train/4/89048/356 +- nucleus_hipsc_train/4/8982/1171 +- nucleus_hipsc_train/4/90088/415 +- nucleus_hipsc_train/4/90858/15658 +- nucleus_hipsc_train/4/90858/16534 +- nucleus_hipsc_train/4/91144/102 +- nucleus_hipsc_train/4/91924/458 +- nucleus_hipsc_train/4/93448/596 +- nucleus_hipsc_train/4/94312/684 +- nucleus_hipsc_train/4/95752/811 +- nucleus_hipsc_train/4/95753/737 +- nucleus_hipsc_train/4/95753/872 +- nucleus_hipsc_train/41/43638/5246 +- nucleus_hipsc_train/41/43639/5265 +- nucleus_hipsc_train/41/43732/16519 +- nucleus_hipsc_train/41/45556/5706 +- nucleus_hipsc_train/41/45556/5734 +- nucleus_hipsc_train/41/45559/5714 +- nucleus_hipsc_train/41/48436/5507 +- nucleus_hipsc_train/41/48534/5575 +- nucleus_hipsc_train/41/48535/5623 +- nucleus_hipsc_train/41/48548/5574 +- nucleus_hipsc_train/41/48548/5589 +- nucleus_hipsc_train/41/49204/5661 +- nucleus_hipsc_train/41/49220/5671 +- nucleus_hipsc_train/41/49698/5819 +- nucleus_hipsc_train/41/49972/5933 +- nucleus_hipsc_train/41/49973/5960 +- nucleus_hipsc_train/41/50263/6077 +- nucleus_hipsc_train/41/50263/6082 +- nucleus_hipsc_train/41/50356/15510 +- nucleus_hipsc_train/41/50356/15578 +- nucleus_hipsc_train/41/50359/15457 +- nucleus_hipsc_train/41/50548/6024 +- nucleus_hipsc_train/41/50551/6022 +- nucleus_hipsc_train/41/53044/15243 +- nucleus_hipsc_train/41/53046/16965 +- nucleus_hipsc_train/41/53428/6238 +- nucleus_hipsc_train/41/53524/15636 +- nucleus_hipsc_train/41/53538/15395 +- nucleus_hipsc_train/41/53731/15920 +- nucleus_hipsc_train/41/55156/6355 +- nucleus_hipsc_train/41/55156/6358 +- nucleus_hipsc_train/41/55158/6324 +- nucleus_hipsc_train/41/55158/6353 +- nucleus_hipsc_train/41/55253/6499 +- nucleus_hipsc_train/41/55256/6482 +- nucleus_hipsc_train/41/55351/6419 +- nucleus_hipsc_train/41/55363/6362 +- nucleus_hipsc_train/41/55925/6584 +- nucleus_hipsc_train/41/56406/6643 +- nucleus_hipsc_train/41/56416/6614 +- nucleus_hipsc_train/41/56418/6626 +- nucleus_hipsc_train/41/56419/6630 +- nucleus_hipsc_train/41/56596/6678 +- nucleus_hipsc_train/41/56896/7720 +- nucleus_hipsc_train/41/57364/6456 +- nucleus_hipsc_train/41/57365/6428 +- nucleus_hipsc_train/41/57367/6430 +- nucleus_hipsc_train/41/57464/6544 +- nucleus_hipsc_train/41/57472/6556 +- nucleus_hipsc_train/41/57472/6565 +- nucleus_hipsc_train/41/58134/6821 +- nucleus_hipsc_train/41/58326/6840 +- nucleus_hipsc_train/41/58420/6971 +- nucleus_hipsc_train/41/58423/6963 +- nucleus_hipsc_train/41/58518/6786 +- nucleus_hipsc_train/41/59285/7118 +- nucleus_hipsc_train/41/59285/7124 +- nucleus_hipsc_train/41/59298/7175 +- nucleus_hipsc_train/41/59380/7015 +- nucleus_hipsc_train/41/59479/7188 +- nucleus_hipsc_train/41/59479/7200 +- nucleus_hipsc_train/41/59480/7179 +- nucleus_hipsc_train/41/60548/7475 +- nucleus_hipsc_train/41/60632/7345 +- nucleus_hipsc_train/41/60726/7399 +- nucleus_hipsc_train/41/60737/7332 +- nucleus_hipsc_train/41/60738/7414 +- nucleus_hipsc_train/41/62740/7068 +- nucleus_hipsc_train/41/62932/6916 +- nucleus_hipsc_train/41/63508/7389 +- nucleus_hipsc_train/41/63523/7383 +- nucleus_hipsc_train/41/63608/7462 +- nucleus_hipsc_train/41/63608/7464 +- nucleus_hipsc_train/41/63620/7451 +- nucleus_hipsc_train/41/63701/7283 +- nucleus_hipsc_train/41/63713/7256 +- nucleus_hipsc_train/41/66292/7775 +- nucleus_hipsc_train/41/66292/7782 +- nucleus_hipsc_train/41/66292/7796 +- nucleus_hipsc_train/41/66296/7788 +- nucleus_hipsc_train/41/67157/7690 +- nucleus_hipsc_train/41/67168/7678 +- nucleus_hipsc_train/41/68131/7834 +- nucleus_hipsc_train/41/68503/9206 +- nucleus_hipsc_train/41/68504/9176 +- nucleus_hipsc_train/41/68504/9197 +- nucleus_hipsc_train/41/68512/9188 +- nucleus_hipsc_train/41/68512/9207 +- nucleus_hipsc_train/41/68512/9212 +- nucleus_hipsc_train/41/68708/9065 +- nucleus_hipsc_train/41/68788/9030 +- nucleus_hipsc_train/41/68800/9019 +- nucleus_hipsc_train/41/69472/9285 +- nucleus_hipsc_train/41/69473/9279 +- nucleus_hipsc_train/41/69474/9306 +- nucleus_hipsc_train/41/70052/15689 +- nucleus_hipsc_train/41/70231/9525 +- nucleus_hipsc_train/41/70232/9551 +- nucleus_hipsc_train/41/72244/8037 +- nucleus_hipsc_train/41/72244/8074 +- nucleus_hipsc_train/41/72256/8049 +- nucleus_hipsc_train/41/72260/8085 +- nucleus_hipsc_train/41/72342/7994 +- nucleus_hipsc_train/41/72356/7962 +- nucleus_hipsc_train/41/72628/8109 +- nucleus_hipsc_train/41/72629/8086 +- nucleus_hipsc_train/41/72630/8119 +- nucleus_hipsc_train/41/72631/8095 +- nucleus_hipsc_train/41/72725/8151 +- nucleus_hipsc_train/41/72726/8128 +- nucleus_hipsc_train/41/72834/8288 +- nucleus_hipsc_train/41/73300/8255 +- nucleus_hipsc_train/41/73396/8265 +- nucleus_hipsc_train/41/73397/8271 +- nucleus_hipsc_train/41/73398/8307 +- nucleus_hipsc_train/41/73495/8186 +- nucleus_hipsc_train/41/73507/8203 +- nucleus_hipsc_train/41/73685/8634 +- nucleus_hipsc_train/41/73687/8628 +- nucleus_hipsc_train/41/73700/8663 +- nucleus_hipsc_train/41/73782/8525 +- nucleus_hipsc_train/41/73782/8576 +- nucleus_hipsc_train/41/73783/8530 +- nucleus_hipsc_train/41/73784/8543 +- nucleus_hipsc_train/41/73879/15995 +- nucleus_hipsc_train/41/73975/15832 +- nucleus_hipsc_train/41/74165/8821 +- nucleus_hipsc_train/41/74168/8793 +- nucleus_hipsc_train/41/74260/8727 +- nucleus_hipsc_train/41/74273/8721 +- nucleus_hipsc_train/41/74371/8941 +- nucleus_hipsc_train/41/74371/8978 +- nucleus_hipsc_train/41/75042/7915 +- nucleus_hipsc_train/41/75124/16978 +- nucleus_hipsc_train/41/75125/16693 +- nucleus_hipsc_train/41/75512/7872 +- nucleus_hipsc_train/41/75796/7941 +- nucleus_hipsc_train/41/75799/7953 +- nucleus_hipsc_train/41/76000/8244 +- nucleus_hipsc_train/41/77250/8868 +- nucleus_hipsc_train/41/77333/9094 +- nucleus_hipsc_train/42/106420/10373 +- nucleus_hipsc_train/42/106421/10380 +- nucleus_hipsc_train/42/106422/10368 +- nucleus_hipsc_train/42/106516/10272 +- nucleus_hipsc_train/42/106518/10239 +- nucleus_hipsc_train/42/106520/10262 +- nucleus_hipsc_train/42/106915/10747 +- nucleus_hipsc_train/42/106996/10652 +- nucleus_hipsc_train/42/106998/10641 +- nucleus_hipsc_train/42/107480/10815 +- nucleus_hipsc_train/42/107480/10822 +- nucleus_hipsc_train/42/107572/12022 +- nucleus_hipsc_train/42/107574/11982 +- nucleus_hipsc_train/42/107574/12039 +- nucleus_hipsc_train/42/107682/11895 +- nucleus_hipsc_train/42/107682/11898 +- nucleus_hipsc_train/42/107684/11928 +- nucleus_hipsc_train/42/107956/11969 +- nucleus_hipsc_train/42/107956/11981 +- nucleus_hipsc_train/42/107958/11911 +- nucleus_hipsc_train/42/107959/12029 +- nucleus_hipsc_train/42/107972/11941 +- nucleus_hipsc_train/42/108148/15673 +- nucleus_hipsc_train/42/108149/12190 +- nucleus_hipsc_train/42/108246/11135 +- nucleus_hipsc_train/42/108248/16355 +- nucleus_hipsc_train/42/108824/15581 +- nucleus_hipsc_train/42/108833/15155 +- nucleus_hipsc_train/42/110548/10130 +- nucleus_hipsc_train/42/110552/10154 +- nucleus_hipsc_train/42/110552/10175 +- nucleus_hipsc_train/42/110645/10108 +- nucleus_hipsc_train/42/110646/10124 +- nucleus_hipsc_train/42/110660/10091 +- nucleus_hipsc_train/42/110947/10199 +- nucleus_hipsc_train/42/111125/10242 +- nucleus_hipsc_train/42/111413/10485 +- nucleus_hipsc_train/42/111415/10486 +- nucleus_hipsc_train/42/111426/10473 +- nucleus_hipsc_train/42/111892/10724 +- nucleus_hipsc_train/42/112084/15061 +- nucleus_hipsc_train/42/112085/16293 +- nucleus_hipsc_train/42/112280/15454 +- nucleus_hipsc_train/42/112565/10904 +- nucleus_hipsc_train/42/112758/16064 +- nucleus_hipsc_train/42/112772/14973 +- nucleus_hipsc_train/42/113432/11852 +- nucleus_hipsc_train/42/113634/10939 +- nucleus_hipsc_train/42/113921/11053 +- nucleus_hipsc_train/42/114209/10977 +- nucleus_hipsc_train/42/114212/10981 +- nucleus_hipsc_train/42/114787/11121 +- nucleus_hipsc_train/42/114788/11097 +- nucleus_hipsc_train/42/114965/11232 +- nucleus_hipsc_train/42/114965/11269 +- nucleus_hipsc_train/42/114979/11222 +- nucleus_hipsc_train/42/115160/12126 +- nucleus_hipsc_train/42/115169/16617 +- nucleus_hipsc_train/42/115349/11410 +- nucleus_hipsc_train/42/115541/15346 +- nucleus_hipsc_train/42/115542/16879 +- nucleus_hipsc_train/42/115552/15185 +- nucleus_hipsc_train/42/115554/15716 +- nucleus_hipsc_train/42/115555/16425 +- nucleus_hipsc_train/42/115556/15703 +- nucleus_hipsc_train/42/115831/11479 +- nucleus_hipsc_train/42/116034/11497 +- nucleus_hipsc_train/42/116309/11595 +- nucleus_hipsc_train/42/116324/11616 +- nucleus_hipsc_train/42/116608/10515 +- nucleus_hipsc_train/42/116608/10614 +- nucleus_hipsc_train/42/116887/10440 +- nucleus_hipsc_train/42/116897/10412 +- nucleus_hipsc_train/42/116900/10422 +- nucleus_hipsc_train/42/117173/10673 +- nucleus_hipsc_train/42/117186/10657 +- nucleus_hipsc_train/42/117557/11347 +- nucleus_hipsc_train/42/117559/11367 +- nucleus_hipsc_train/42/117572/11385 +- nucleus_hipsc_train/42/117847/11299 +- nucleus_hipsc_train/42/118420/11731 +- nucleus_hipsc_train/42/118423/11658 +- nucleus_hipsc_train/42/118712/11569 +- nucleus_hipsc_train/42/118806/11804 +- nucleus_hipsc_train/42/118808/11800 +- nucleus_hipsc_train/42/121791/16666 +- nucleus_hipsc_train/42/121793/15852 +- nucleus_hipsc_train/42/121806/15946 +- nucleus_hipsc_train/42/123328/15550 +- nucleus_hipsc_train/42/123328/17092 +- nucleus_hipsc_train/42/123714/16851 +- nucleus_hipsc_train/42/123903/15431 +- nucleus_hipsc_train/42/124002/16132 +- nucleus_hipsc_train/42/124014/16885 +- nucleus_hipsc_train/42/124205/15565 +- nucleus_hipsc_train/42/124287/15382 +- nucleus_hipsc_train/42/124290/15483 +- nucleus_hipsc_train/42/124291/15731 +- nucleus_hipsc_train/42/124299/16712 +- nucleus_hipsc_train/42/124301/15843 +- nucleus_hipsc_train/42/127171/12333 +- nucleus_hipsc_train/42/127647/12252 +- nucleus_hipsc_train/42/127648/12223 +- nucleus_hipsc_train/42/127649/12208 +- nucleus_hipsc_train/42/127650/12238 +- nucleus_hipsc_train/42/127650/12256 +- nucleus_hipsc_train/42/127651/12217 +- nucleus_hipsc_train/42/127651/12239 +- nucleus_hipsc_train/42/127852/12320 +- nucleus_hipsc_train/42/127935/12457 +- nucleus_hipsc_train/42/127947/12485 +- nucleus_hipsc_train/42/128416/12512 +- nucleus_hipsc_train/42/128514/12657 +- nucleus_hipsc_train/42/128514/12667 +- nucleus_hipsc_train/42/128525/12654 +- nucleus_hipsc_train/42/128715/12598 +- nucleus_hipsc_train/42/128718/12626 +- nucleus_hipsc_train/42/128719/12625 +- nucleus_hipsc_train/42/129473/12830 +- nucleus_hipsc_train/42/129473/12852 +- nucleus_hipsc_train/42/129571/12811 +- nucleus_hipsc_train/42/129583/12802 +- nucleus_hipsc_train/42/129774/12715 +- nucleus_hipsc_train/42/129855/12931 +- nucleus_hipsc_train/42/130155/13043 +- nucleus_hipsc_train/42/130527/12960 +- nucleus_hipsc_train/42/130625/16186 +- nucleus_hipsc_train/42/130707/13231 +- nucleus_hipsc_train/42/130722/17097 +- nucleus_hipsc_train/42/132173/13409 +- nucleus_hipsc_train/42/132175/13365 +- nucleus_hipsc_train/42/132653/13278 +- nucleus_hipsc_train/42/132831/13415 +- nucleus_hipsc_train/42/132844/13432 +- nucleus_hipsc_train/42/132845/13448 +- nucleus_hipsc_train/42/132929/13513 +- nucleus_hipsc_train/42/133133/13640 +- nucleus_hipsc_train/42/133323/13465 +- nucleus_hipsc_train/42/133324/13457 +- nucleus_hipsc_train/42/133325/13497 +- nucleus_hipsc_train/42/133503/13577 +- nucleus_hipsc_train/42/133504/13572 +- nucleus_hipsc_train/42/133602/13711 +- nucleus_hipsc_train/42/133711/13788 +- nucleus_hipsc_train/42/134272/13918 +- nucleus_hipsc_train/42/134286/13916 +- nucleus_hipsc_train/42/134656/13884 +- nucleus_hipsc_train/42/135272/14059 +- nucleus_hipsc_train/42/135440/14128 +- nucleus_hipsc_train/42/135525/14245 +- nucleus_hipsc_train/42/135614/14178 +- nucleus_hipsc_train/42/137434/14771 +- nucleus_hipsc_train/42/137464/14708 +- nucleus_hipsc_train/42/137767/14413 +- nucleus_hipsc_train/42/137772/14516 +- nucleus_hipsc_train/42/137956/15501 +- nucleus_hipsc_train/42/137956/16613 +- nucleus_hipsc_train/42/137956/17196 +- nucleus_hipsc_train/42/137956/17224 +- nucleus_hipsc_train/42/138024/15890 +- nucleus_hipsc_train/42/138028/16174 +- nucleus_hipsc_train/42/138032/15577 +- nucleus_hipsc_train/42/138261/16083 +- nucleus_hipsc_train/42/77912/9479 +- nucleus_hipsc_train/42/77912/9520 +- nucleus_hipsc_train/42/77923/9543 +- nucleus_hipsc_train/42/78389/9675 +- nucleus_hipsc_train/42/78391/9672 +- nucleus_hipsc_train/42/78487/9750 +- nucleus_hipsc_train/42/78487/9758 +- nucleus_hipsc_train/42/78691/9802 +- nucleus_hipsc_train/42/79541/9897 +- nucleus_hipsc_train/42/79552/9894 +- nucleus_hipsc_train/42/79554/9874 +- nucleus_hipsc_train/42/79828/9972 +- nucleus_hipsc_train/42/79831/9969 +- nucleus_hipsc_train/42/79832/9978 +- nucleus_hipsc_train/42/79841/9963 +- nucleus_hipsc_train/42/80023/15006 +- nucleus_hipsc_train/42/80033/15189 +- nucleus_hipsc_train/42/80035/9980 +- nucleus_hipsc_train/42/80224/9960 +- nucleus_hipsc_train/42/83392/9630 +- h2b_a549_mantis_2026_03_26_train/B/2/000002 +- h2b_a549_mantis_2026_03_26_train/B/2/000003 +- h2b_a549_mantis_2026_03_26_train/B/2/000005 +- h2b_a549_mantis_2026_03_26_train/B/2/000006 +- h2b_a549_mantis_2026_03_26_train/B/2/000008 +- h2b_a549_mantis_2026_03_26_train/B/2/001000 +- h2b_a549_mantis_2026_03_26_train/B/2/001001 +- h2b_a549_mantis_2026_03_26_train/B/2/001002 +- h2b_a549_mantis_2026_03_26_train/B/2/001003 +- h2b_a549_mantis_2026_03_26_train/B/2/001004 +- h2b_a549_mantis_2026_03_26_train/B/2/001005 +- h2b_a549_mantis_2026_03_26_train/B/2/001006 +- h2b_a549_mantis_2026_03_26_train/B/2/001007 +- h2b_a549_mantis_2026_03_26_train/B/2/001008 +- h2b_a549_mantis_2026_03_26_train/B/2/002000 +- h2b_a549_mantis_2026_03_26_train/B/2/002001 +- h2b_a549_mantis_2026_03_26_train/B/2/002002 +- h2b_a549_mantis_2026_03_26_train/B/2/002003 +- h2b_a549_mantis_2026_03_26_train/B/2/002004 +- h2b_a549_mantis_2026_03_26_train/B/2/002005 +- h2b_a549_mantis_2026_03_26_train/B/2/002006 +- h2b_a549_mantis_2026_03_26_train/B/2/002007 +- h2b_a549_mantis_2026_03_26_train/B/2/002008 +- h2b_a549_mantis_2026_03_26_train/B/2/003000 +- h2b_a549_mantis_2026_03_26_train/B/2/003002 +- h2b_a549_mantis_2026_03_26_train/B/2/003003 +- h2b_a549_mantis_2026_03_26_train/B/2/003005 +- h2b_a549_mantis_2026_03_26_train/B/2/003006 +- h2b_a549_mantis_2026_03_26_train/B/2/003008 +- h2b_a549_mantis_2026_03_26_train/B/2/004000 +- h2b_a549_mantis_2026_03_26_train/B/2/004001 +- h2b_a549_mantis_2026_03_26_train/B/2/004002 +- h2b_a549_mantis_2026_03_26_train/B/2/004003 +- h2b_a549_mantis_2026_03_26_train/B/2/004004 +- h2b_a549_mantis_2026_03_26_train/B/2/004005 +- h2b_a549_mantis_2026_03_26_train/B/2/004006 +- h2b_a549_mantis_2026_03_26_train/B/2/004007 +- h2b_a549_mantis_2026_03_26_train/B/2/004008 +- h2b_a549_mantis_2026_03_26_train/B/2/005000 +- h2b_a549_mantis_2026_03_26_train/B/2/005002 +- h2b_a549_mantis_2026_03_26_train/B/2/005003 +- h2b_a549_mantis_2026_03_26_train/B/2/005005 +- h2b_a549_mantis_2026_03_26_train/B/2/005006 +- h2b_a549_mantis_2026_03_26_train/B/2/005008 +- h2b_a549_mantis_2026_03_26_train/B/2/006000 +- h2b_a549_mantis_2026_03_26_train/B/2/006001 +- h2b_a549_mantis_2026_03_26_train/B/2/006002 +- h2b_a549_mantis_2026_03_26_train/B/2/006003 +- h2b_a549_mantis_2026_03_26_train/B/2/006004 +- h2b_a549_mantis_2026_03_26_train/B/2/006005 +- h2b_a549_mantis_2026_03_26_train/B/2/006006 +- h2b_a549_mantis_2026_03_26_train/B/2/006007 +- h2b_a549_mantis_2026_03_26_train/B/2/006008 +- h2b_a549_mantis_2026_03_26_train/B/2/007000 +- h2b_a549_mantis_2026_03_26_train/B/2/007001 +- h2b_a549_mantis_2026_03_26_train/B/2/007002 +- h2b_a549_mantis_2026_03_26_train/B/2/007003 +- h2b_a549_mantis_2026_03_26_train/B/2/007004 +- h2b_a549_mantis_2026_03_26_train/B/2/007005 +- h2b_a549_mantis_2026_03_26_train/B/2/007006 +- h2b_a549_mantis_2026_03_26_train/B/2/007007 +- h2b_a549_mantis_2026_03_26_train/B/2/007008 +- h2b_a549_mantis_2026_03_26_train/B/2/008000 +- h2b_a549_mantis_2026_03_26_train/B/2/008002 +- h2b_a549_mantis_2026_03_26_train/B/2/008003 +- h2b_a549_mantis_2026_03_26_train/B/2/008005 +- h2b_a549_mantis_2026_03_26_train/B/2/008006 +- h2b_a549_mantis_2026_03_26_train/B/2/008008 +test_fovs: +- nucleus_hipsc_test/4/11393/1428 +- nucleus_hipsc_test/4/11479/1481 +- nucleus_hipsc_test/4/18007/1641 +- nucleus_hipsc_test/4/18102/1710 +- nucleus_hipsc_test/4/18485/1842 +- nucleus_hipsc_test/4/22901/3306 +- nucleus_hipsc_test/4/27797/2857 +- nucleus_hipsc_test/4/28759/3400 +- nucleus_hipsc_test/4/29060/3786 +- nucleus_hipsc_test/4/29140/3687 +- nucleus_hipsc_test/4/29334/3890 +- nucleus_hipsc_test/4/30293/3915 +- nucleus_hipsc_test/4/31736/15232 +- nucleus_hipsc_test/4/32024/4089 +- nucleus_hipsc_test/4/34998/4271 +- nucleus_hipsc_test/4/35284/4501 +- nucleus_hipsc_test/4/36643/4930 +- nucleus_hipsc_test/4/37601/5175 +- nucleus_hipsc_test/4/38464/5176 +- nucleus_hipsc_test/4/4556/15828 +- nucleus_hipsc_test/4/4556/16242 +- nucleus_hipsc_test/4/5910/824 +- nucleus_hipsc_test/4/6497/1014 +- nucleus_hipsc_test/4/6775/1242 +- nucleus_hipsc_test/4/8706/1138 +- nucleus_hipsc_test/4/94507/699 +- nucleus_hipsc_test/41/44212/5751 +- nucleus_hipsc_test/41/48436/5515 +- nucleus_hipsc_test/41/48536/5593 +- nucleus_hipsc_test/41/49121/5716 +- nucleus_hipsc_test/41/49121/5777 +- nucleus_hipsc_test/41/49204/5680 +- nucleus_hipsc_test/41/49888/5888 +- nucleus_hipsc_test/41/49975/5926 +- nucleus_hipsc_test/41/50548/6016 +- nucleus_hipsc_test/41/52564/5966 +- nucleus_hipsc_test/41/53048/15203 +- nucleus_hipsc_test/41/55160/6367 +- nucleus_hipsc_test/41/55348/6437 +- nucleus_hipsc_test/41/55350/6427 +- nucleus_hipsc_test/41/58326/6874 +- nucleus_hipsc_test/41/58517/6781 +- nucleus_hipsc_test/41/60728/7413 +- nucleus_hipsc_test/41/62754/7076 +- nucleus_hipsc_test/41/63524/7359 +- nucleus_hipsc_test/41/63524/7400 +- nucleus_hipsc_test/41/63713/7287 +- nucleus_hipsc_test/41/66020/7541 +- nucleus_hipsc_test/41/67168/7688 +- nucleus_hipsc_test/41/68116/7831 +- nucleus_hipsc_test/41/68598/9132 +- nucleus_hipsc_test/41/68804/8999 +- nucleus_hipsc_test/41/68884/9247 +- nucleus_hipsc_test/41/68885/9316 +- nucleus_hipsc_test/41/70240/9487 +- nucleus_hipsc_test/41/72356/7974 +- nucleus_hipsc_test/41/72629/8071 +- nucleus_hipsc_test/41/72725/8138 +- nucleus_hipsc_test/41/72727/8125 +- nucleus_hipsc_test/41/73112/8476 +- nucleus_hipsc_test/41/73304/8259 +- nucleus_hipsc_test/41/73686/8660 +- nucleus_hipsc_test/41/73686/8668 +- nucleus_hipsc_test/41/73783/8567 +- nucleus_hipsc_test/41/74264/8751 +- nucleus_hipsc_test/41/74272/8740 +- nucleus_hipsc_test/41/74356/8919 +- nucleus_hipsc_test/41/75800/8019 +- nucleus_hipsc_test/41/75808/7975 +- nucleus_hipsc_test/42/107478/10817 +- nucleus_hipsc_test/42/114584/12053 +- nucleus_hipsc_test/42/115556/15421 +- nucleus_hipsc_test/42/116598/10604 +- nucleus_hipsc_test/42/117557/11343 +- nucleus_hipsc_test/42/118901/11674 +- nucleus_hipsc_test/42/118912/11694 +- nucleus_hipsc_test/42/123916/16655 +- nucleus_hipsc_test/42/124001/16229 +- nucleus_hipsc_test/42/127171/12338 +- nucleus_hipsc_test/42/127276/23725 +- nucleus_hipsc_test/42/127939/12482 +- nucleus_hipsc_test/42/128428/12536 +- nucleus_hipsc_test/42/128523/12637 +- nucleus_hipsc_test/42/129665/12780 +- nucleus_hipsc_test/42/129855/12890 +- nucleus_hipsc_test/42/132463/13304 +- nucleus_hipsc_test/42/132834/13446 +- nucleus_hipsc_test/42/133599/13746 +- nucleus_hipsc_test/42/135439/14132 +- nucleus_hipsc_test/42/137449/14744 +- nucleus_hipsc_test/42/137455/14731 +- nucleus_hipsc_test/42/137460/14685 +- nucleus_hipsc_test/42/137582/14642 +- nucleus_hipsc_test/42/137774/14522 +- nucleus_hipsc_test/42/137820/14488 +- nucleus_hipsc_test/42/137953/15518 +- nucleus_hipsc_test/42/77924/9512 +- nucleus_hipsc_test/42/80023/9994 +- nucleus_hipsc_test/42/82708/16181 +- nucleus_hipsc_test/42/84449/15422 +- h2b_a549_mantis_2026_03_26_test/B/2/000001 +- h2b_a549_mantis_2026_03_26_test/B/2/000004 +- h2b_a549_mantis_2026_03_26_test/B/2/000007 +- h2b_a549_mantis_2026_03_26_test/B/2/003001 +- h2b_a549_mantis_2026_03_26_test/B/2/003004 +- h2b_a549_mantis_2026_03_26_test/B/2/003007 +- h2b_a549_mantis_2026_03_26_test/B/2/005001 +- h2b_a549_mantis_2026_03_26_test/B/2/005004 +- h2b_a549_mantis_2026_03_26_test/B/2/005007 +- h2b_a549_mantis_2026_03_26_test/B/2/008001 +- h2b_a549_mantis_2026_03_26_test/B/2/008004 +- h2b_a549_mantis_2026_03_26_test/B/2/008007 diff --git a/applications/dynacell/configs/collections/virtual_staining/sec61b_ipsc_v1.yaml b/applications/dynacell/configs/collections/virtual_staining/sec61b_ipsc_v1.yaml new file mode 100644 index 000000000..6ac12c675 --- /dev/null +++ b/applications/dynacell/configs/collections/virtual_staining/sec61b_ipsc_v1.yaml @@ -0,0 +1,587 @@ +name: sec61b_ipsc_v1 +description: Frozen benchmark collection for 'aics-hipsc' target 'sec61b'. Channels + and FOV membership captured from the live train/test zarr stores at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-21T00:00:00Z' + created_by: Alex Kalinin +experiments: +- name: sec61b_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: SEC61B + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: sec61b_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/SEC61B.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: SEC61B + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +train_fovs: +- sec61b_hipsc_train/4/38452/5161 +- sec61b_hipsc_train/4/38452/5165 +- sec61b_hipsc_train/4/38452/5177 +- sec61b_hipsc_train/4/38452/5184 +- sec61b_hipsc_train/4/38452/5194 +- sec61b_hipsc_train/4/38452/5198 +- sec61b_hipsc_train/4/38464/5157 +- sec61b_hipsc_train/4/38464/5159 +- sec61b_hipsc_train/4/38464/5176 +- sec61b_hipsc_train/4/38464/5179 +- sec61b_hipsc_train/4/38464/5181 +- sec61b_hipsc_train/4/38464/5186 +- sec61b_hipsc_train/4/38464/5190 +- sec61b_hipsc_train/4/38464/5199 +- sec61b_hipsc_train/4/38464/5202 +- sec61b_hipsc_train/4/38465/5164 +- sec61b_hipsc_train/4/38465/5171 +- sec61b_hipsc_train/4/38465/5191 +- sec61b_hipsc_train/4/38465/5195 +- sec61b_hipsc_train/4/38465/5197 +- sec61b_hipsc_train/4/38466/5155 +- sec61b_hipsc_train/4/38466/5168 +- sec61b_hipsc_train/4/38466/5188 +- sec61b_hipsc_train/4/38466/5192 +- sec61b_hipsc_train/4/38466/5193 +- sec61b_hipsc_train/4/38466/5196 +- sec61b_hipsc_train/4/39124/5221 +- sec61b_hipsc_train/4/39124/5223 +- sec61b_hipsc_train/4/39124/5247 +- sec61b_hipsc_train/4/39124/5258 +- sec61b_hipsc_train/4/39124/5280 +- sec61b_hipsc_train/4/39125/5264 +- sec61b_hipsc_train/4/39126/5229 +- sec61b_hipsc_train/4/39127/5283 +- sec61b_hipsc_train/4/39128/5219 +- sec61b_hipsc_train/4/39128/5260 +- sec61b_hipsc_train/4/39128/5272 +- sec61b_hipsc_train/4/39136/5225 +- sec61b_hipsc_train/4/39136/5234 +- sec61b_hipsc_train/4/39136/5236 +- sec61b_hipsc_train/4/39136/5239 +- sec61b_hipsc_train/4/39137/5243 +- sec61b_hipsc_train/4/39137/5266 +- sec61b_hipsc_train/4/39137/5274 +- sec61b_hipsc_train/4/39137/5277 +- sec61b_hipsc_train/4/39138/5256 +- sec61b_hipsc_train/4/39138/5262 +- sec61b_hipsc_train/4/39138/5270 +- sec61b_hipsc_train/4/39139/5220 +- sec61b_hipsc_train/4/39139/5244 +- sec61b_hipsc_train/4/39139/5249 +- sec61b_hipsc_train/4/39139/5250 +- sec61b_hipsc_train/4/39140/5222 +- sec61b_hipsc_train/4/39140/5232 +- sec61b_hipsc_train/4/39140/5240 +- sec61b_hipsc_train/4/39222/5288 +- sec61b_hipsc_train/4/39222/5291 +- sec61b_hipsc_train/4/39222/5298 +- sec61b_hipsc_train/4/39222/5303 +- sec61b_hipsc_train/4/39222/5324 +- sec61b_hipsc_train/4/39224/5294 +- sec61b_hipsc_train/4/39224/5302 +- sec61b_hipsc_train/4/39224/5307 +- sec61b_hipsc_train/4/39224/5321 +- sec61b_hipsc_train/4/39224/5326 +- sec61b_hipsc_train/4/39224/5332 +- sec61b_hipsc_train/4/39232/5278 +- sec61b_hipsc_train/4/39232/5318 +- sec61b_hipsc_train/4/39232/5323 +- sec61b_hipsc_train/4/39232/5330 +- sec61b_hipsc_train/4/39233/5299 +- sec61b_hipsc_train/4/39233/5309 +- sec61b_hipsc_train/4/39233/5322 +- sec61b_hipsc_train/4/39236/5316 +- sec61b_hipsc_train/4/39236/5317 +- sec61b_hipsc_train/4/40084/5359 +- sec61b_hipsc_train/4/40084/5380 +- sec61b_hipsc_train/4/40084/5407 +- sec61b_hipsc_train/4/40084/5429 +- sec61b_hipsc_train/4/40085/5371 +- sec61b_hipsc_train/4/40085/5383 +- sec61b_hipsc_train/4/40085/5389 +- sec61b_hipsc_train/4/40086/5401 +- sec61b_hipsc_train/4/40087/5377 +- sec61b_hipsc_train/4/40087/5405 +- sec61b_hipsc_train/4/40087/5428 +- sec61b_hipsc_train/4/40088/5365 +- sec61b_hipsc_train/4/40088/5368 +- sec61b_hipsc_train/4/40088/5392 +- sec61b_hipsc_train/4/40088/5398 +- sec61b_hipsc_train/4/40088/5403 +- sec61b_hipsc_train/4/40088/5417 +- sec61b_hipsc_train/4/40088/5422 +- sec61b_hipsc_train/4/40088/5424 +- sec61b_hipsc_train/4/40088/5430 +- sec61b_hipsc_train/4/40098/5386 +- sec61b_hipsc_train/4/40098/5409 +- sec61b_hipsc_train/4/40098/5427 +- sec61b_hipsc_train/4/40180/5447 +- sec61b_hipsc_train/4/40180/5461 +- sec61b_hipsc_train/4/40180/5475 +- sec61b_hipsc_train/4/40180/5497 +- sec61b_hipsc_train/4/40181/5435 +- sec61b_hipsc_train/4/40181/5441 +- sec61b_hipsc_train/4/40181/5443 +- sec61b_hipsc_train/4/40181/5481 +- sec61b_hipsc_train/4/40182/5432 +- sec61b_hipsc_train/4/40182/5433 +- sec61b_hipsc_train/4/40182/5455 +- sec61b_hipsc_train/4/40182/5498 +- sec61b_hipsc_train/4/40184/5439 +- sec61b_hipsc_train/4/40184/5457 +- sec61b_hipsc_train/4/40194/5459 +- sec61b_hipsc_train/4/40194/5463 +- sec61b_hipsc_train/4/40195/5436 +- sec61b_hipsc_train/4/40195/5483 +- sec61b_hipsc_train/4/40195/5489 +- sec61b_hipsc_train/4/40195/5491 +- sec61b_hipsc_train/4/40375/4566 +- sec61b_hipsc_train/4/40375/4599 +- sec61b_hipsc_train/4/40375/4608 +- sec61b_hipsc_train/4/40376/4563 +- sec61b_hipsc_train/4/40376/4584 +- sec61b_hipsc_train/4/40376/4605 +- sec61b_hipsc_train/4/40376/4607 +- sec61b_hipsc_train/4/40376/4609 +- sec61b_hipsc_train/4/40385/4557 +- sec61b_hipsc_train/4/40385/4559 +- sec61b_hipsc_train/4/40385/4578 +- sec61b_hipsc_train/4/40385/4593 +- sec61b_hipsc_train/4/40385/4614 +- sec61b_hipsc_train/4/40386/4580 +- sec61b_hipsc_train/4/40386/4611 +- sec61b_hipsc_train/4/40386/4613 +- sec61b_hipsc_train/4/40387/4561 +- sec61b_hipsc_train/4/40387/4582 +- sec61b_hipsc_train/4/40387/4586 +- sec61b_hipsc_train/4/40387/4595 +- sec61b_hipsc_train/4/40387/4597 +- sec61b_hipsc_train/4/40388/4574 +- sec61b_hipsc_train/4/40388/4588 +- sec61b_hipsc_train/4/40468/4620 +- sec61b_hipsc_train/4/40468/4650 +- sec61b_hipsc_train/4/40468/4653 +- sec61b_hipsc_train/4/40468/4655 +- sec61b_hipsc_train/4/40469/4641 +- sec61b_hipsc_train/4/40469/4666 +- sec61b_hipsc_train/4/40469/4673 +- sec61b_hipsc_train/4/40470/4615 +- sec61b_hipsc_train/4/40470/4616 +- sec61b_hipsc_train/4/40470/4671 +- sec61b_hipsc_train/4/40470/4675 +- sec61b_hipsc_train/4/40470/4677 +- sec61b_hipsc_train/4/40471/4632 +- sec61b_hipsc_train/4/40471/4657 +- sec61b_hipsc_train/4/40471/4664 +- sec61b_hipsc_train/4/40481/4622 +- sec61b_hipsc_train/4/40481/4633 +- sec61b_hipsc_train/4/40481/4647 +- sec61b_hipsc_train/4/40481/4668 +- sec61b_hipsc_train/4/40483/4617 +- sec61b_hipsc_train/4/40483/4619 +- sec61b_hipsc_train/4/40483/4629 +- sec61b_hipsc_train/4/40484/4618 +- sec61b_hipsc_train/4/40484/4626 +- sec61b_hipsc_train/4/40484/4663 +- sec61b_hipsc_train/4/40960/4625 +- sec61b_hipsc_train/4/40960/4628 +- sec61b_hipsc_train/4/40960/4640 +- sec61b_hipsc_train/4/40960/4654 +- sec61b_hipsc_train/4/40960/4656 +- sec61b_hipsc_train/4/40960/4674 +- sec61b_hipsc_train/4/40960/4678 +- sec61b_hipsc_train/4/40961/4635 +- sec61b_hipsc_train/4/40961/4669 +- sec61b_hipsc_train/4/40962/4676 +- sec61b_hipsc_train/4/40964/4623 +- sec61b_hipsc_train/4/40964/4631 +- sec61b_hipsc_train/4/40964/4649 +- sec61b_hipsc_train/4/40964/4660 +- sec61b_hipsc_train/4/40964/4667 +- sec61b_hipsc_train/4/40964/4672 +- sec61b_hipsc_train/4/41044/4843 +- sec61b_hipsc_train/4/41044/4847 +- sec61b_hipsc_train/4/41044/4851 +- sec61b_hipsc_train/4/41044/4876 +- sec61b_hipsc_train/4/41044/4895 +- sec61b_hipsc_train/4/41045/4853 +- sec61b_hipsc_train/4/41045/4873 +- sec61b_hipsc_train/4/41045/4889 +- sec61b_hipsc_train/4/41045/4893 +- sec61b_hipsc_train/4/41046/4900 +- sec61b_hipsc_train/4/41047/4845 +- sec61b_hipsc_train/4/41047/4882 +- sec61b_hipsc_train/4/41047/4883 +- sec61b_hipsc_train/4/41047/4902 +- sec61b_hipsc_train/4/41057/4860 +- sec61b_hipsc_train/4/41057/4864 +- sec61b_hipsc_train/4/41057/4875 +- sec61b_hipsc_train/4/41057/4877 +- sec61b_hipsc_train/4/41057/4896 +- sec61b_hipsc_train/4/41058/4855 +- sec61b_hipsc_train/4/41058/4879 +- sec61b_hipsc_train/4/41058/4897 +- sec61b_hipsc_train/4/41058/4899 +- sec61b_hipsc_train/4/41059/4841 +- sec61b_hipsc_train/4/41059/4867 +- sec61b_hipsc_train/4/41059/4884 +- sec61b_hipsc_train/4/41059/4888 +- sec61b_hipsc_train/4/41059/4890 +- sec61b_hipsc_train/4/41059/4892 +- sec61b_hipsc_train/4/41060/4859 +- sec61b_hipsc_train/4/41060/4862 +- sec61b_hipsc_train/4/41060/4878 +- sec61b_hipsc_train/4/41060/4880 +- sec61b_hipsc_train/4/41060/4881 +- sec61b_hipsc_train/4/41060/4894 +- sec61b_hipsc_train/4/41060/4898 +- sec61b_hipsc_train/4/41237/4813 +- sec61b_hipsc_train/4/41237/4826 +- sec61b_hipsc_train/4/41237/4840 +- sec61b_hipsc_train/4/41237/4842 +- sec61b_hipsc_train/4/41237/4861 +- sec61b_hipsc_train/4/41237/4865 +- sec61b_hipsc_train/4/41237/4870 +- sec61b_hipsc_train/4/41238/4815 +- sec61b_hipsc_train/4/41238/4816 +- sec61b_hipsc_train/4/41238/4819 +- sec61b_hipsc_train/4/41238/4827 +- sec61b_hipsc_train/4/41238/4839 +- sec61b_hipsc_train/4/41238/4844 +- sec61b_hipsc_train/4/41238/4874 +- sec61b_hipsc_train/4/41239/4817 +- sec61b_hipsc_train/4/41239/4824 +- sec61b_hipsc_train/4/41239/4830 +- sec61b_hipsc_train/4/41239/4833 +- sec61b_hipsc_train/4/41239/4836 +- sec61b_hipsc_train/4/41239/4838 +- sec61b_hipsc_train/4/41240/4814 +- sec61b_hipsc_train/4/41240/4820 +- sec61b_hipsc_train/4/41240/4821 +- sec61b_hipsc_train/4/41240/4825 +- sec61b_hipsc_train/4/41240/4831 +- sec61b_hipsc_train/4/41240/4852 +- sec61b_hipsc_train/4/41240/4858 +- sec61b_hipsc_train/4/41240/4866 +- sec61b_hipsc_train/4/41249/4835 +- sec61b_hipsc_train/4/41249/4837 +- sec61b_hipsc_train/4/41249/4868 +- sec61b_hipsc_train/4/41335/4810 +- sec61b_hipsc_train/4/41347/4804 +- sec61b_hipsc_train/4/41347/4808 +- sec61b_hipsc_train/4/41347/4812 +- sec61b_hipsc_train/4/41348/4805 +- sec61b_hipsc_train/4/41348/4806 +- sec61b_hipsc_train/4/41348/4807 +- sec61b_hipsc_train/4/41348/4811 +- sec61b_hipsc_train/4/41428/4714 +- sec61b_hipsc_train/4/41428/4723 +- sec61b_hipsc_train/4/41428/4737 +- sec61b_hipsc_train/4/41428/4739 +- sec61b_hipsc_train/4/41430/4722 +- sec61b_hipsc_train/4/41430/4732 +- sec61b_hipsc_train/4/41430/4733 +- sec61b_hipsc_train/4/41430/4741 +- sec61b_hipsc_train/4/41430/4742 +- sec61b_hipsc_train/4/41432/4716 +- sec61b_hipsc_train/4/41432/4719 +- sec61b_hipsc_train/4/41432/4720 +- sec61b_hipsc_train/4/41432/4724 +- sec61b_hipsc_train/4/41432/4726 +- sec61b_hipsc_train/4/41432/4740 +- sec61b_hipsc_train/4/41441/4721 +- sec61b_hipsc_train/4/41441/4727 +- sec61b_hipsc_train/4/41441/4728 +- sec61b_hipsc_train/4/41441/4731 +- sec61b_hipsc_train/4/41441/4734 +- sec61b_hipsc_train/4/41441/4735 +- sec61b_hipsc_train/4/41908/5019 +- sec61b_hipsc_train/4/41908/5021 +- sec61b_hipsc_train/4/41908/5043 +- sec61b_hipsc_train/4/41908/5098 +- sec61b_hipsc_train/4/41908/5099 +- sec61b_hipsc_train/4/41909/5025 +- sec61b_hipsc_train/4/41909/5035 +- sec61b_hipsc_train/4/41909/5046 +- sec61b_hipsc_train/4/41909/5082 +- sec61b_hipsc_train/4/41909/5084 +- sec61b_hipsc_train/4/41909/5092 +- sec61b_hipsc_train/4/41909/5096 +- sec61b_hipsc_train/4/41910/5017 +- sec61b_hipsc_train/4/41910/5023 +- sec61b_hipsc_train/4/41910/5033 +- sec61b_hipsc_train/4/41910/5093 +- sec61b_hipsc_train/4/41911/5015 +- sec61b_hipsc_train/4/41911/5029 +- sec61b_hipsc_train/4/41911/5055 +- sec61b_hipsc_train/4/41911/5064 +- sec61b_hipsc_train/4/41911/5079 +- sec61b_hipsc_train/4/41911/5080 +- sec61b_hipsc_train/4/41911/5086 +- sec61b_hipsc_train/4/41911/5094 +- sec61b_hipsc_train/4/41912/5039 +- sec61b_hipsc_train/4/41912/5041 +- sec61b_hipsc_train/4/41912/5052 +- sec61b_hipsc_train/4/41912/5074 +- sec61b_hipsc_train/4/41912/5095 +- sec61b_hipsc_train/4/42197/5020 +- sec61b_hipsc_train/4/42197/5026 +- sec61b_hipsc_train/4/42197/5030 +- sec61b_hipsc_train/4/42197/5036 +- sec61b_hipsc_train/4/42197/5075 +- sec61b_hipsc_train/4/42199/5032 +- sec61b_hipsc_train/4/42199/5045 +- sec61b_hipsc_train/4/42199/5063 +- sec61b_hipsc_train/4/42199/5066 +- sec61b_hipsc_train/4/42199/5069 +- sec61b_hipsc_train/4/42200/5016 +- sec61b_hipsc_train/4/42200/5028 +- sec61b_hipsc_train/4/42200/5038 +- sec61b_hipsc_train/4/42211/5018 +- sec61b_hipsc_train/4/42211/5024 +- sec61b_hipsc_train/4/42211/5051 +- sec61b_hipsc_train/4/42211/5053 +- sec61b_hipsc_train/4/42211/5057 +- sec61b_hipsc_train/42/136118/15182 +- sec61b_hipsc_train/42/136118/15269 +- sec61b_hipsc_train/42/136118/16846 +- sec61b_hipsc_train/42/136119/14226 +- sec61b_hipsc_train/42/136119/14227 +- sec61b_hipsc_train/42/136119/15430 +- sec61b_hipsc_train/42/136119/15573 +- sec61b_hipsc_train/42/136120/15452 +- sec61b_hipsc_train/42/136120/15958 +- sec61b_hipsc_train/42/136120/16873 +- sec61b_hipsc_train/42/136121/15700 +- sec61b_hipsc_train/42/136121/16618 +- sec61b_hipsc_train/42/136121/17149 +- sec61b_hipsc_train/42/136122/16832 +- sec61b_hipsc_train/42/136122/16883 +- sec61b_hipsc_train/42/136122/16987 +- sec61b_hipsc_train/42/136122/17182 +- sec61b_hipsc_train/42/136124/15667 +- sec61b_hipsc_train/42/136124/15715 +- sec61b_hipsc_train/42/136126/15932 +- sec61b_hipsc_train/42/136126/16322 +- sec61b_hipsc_train/42/138024/15523 +- sec61b_hipsc_train/42/138024/15890 +- sec61b_hipsc_train/42/138024/16225 +- sec61b_hipsc_train/42/138024/16287 +- sec61b_hipsc_train/42/138024/16991 +- sec61b_hipsc_train/42/138025/15979 +- sec61b_hipsc_train/42/138025/16227 +- sec61b_hipsc_train/42/138025/16897 +- sec61b_hipsc_train/42/138025/17204 +- sec61b_hipsc_train/42/138025/17241 +- sec61b_hipsc_train/42/138026/15744 +- sec61b_hipsc_train/42/138026/16036 +- sec61b_hipsc_train/42/138026/16240 +- sec61b_hipsc_train/42/138026/17153 +- sec61b_hipsc_train/42/138026/17201 +- sec61b_hipsc_train/42/138026/17206 +- sec61b_hipsc_train/42/138026/17257 +- sec61b_hipsc_train/42/138027/17190 +- sec61b_hipsc_train/42/138027/17231 +- sec61b_hipsc_train/42/138027/17262 +- sec61b_hipsc_train/42/138028/15886 +- sec61b_hipsc_train/42/138028/16174 +- sec61b_hipsc_train/42/138028/16396 +- sec61b_hipsc_train/42/138028/17142 +- sec61b_hipsc_train/42/138028/17192 +- sec61b_hipsc_train/42/138028/17244 +- sec61b_hipsc_train/42/138030/15632 +- sec61b_hipsc_train/42/138030/15792 +- sec61b_hipsc_train/42/138030/15894 +- sec61b_hipsc_train/42/138032/15614 +- sec61b_hipsc_train/42/138032/15851 +- sec61b_hipsc_train/42/138032/16266 +- sec61b_hipsc_train/42/138032/16928 +- sec61b_hipsc_train/42/138032/17205 +- sec61b_hipsc_train/42/138032/17209 +- sec61b_hipsc_train/42/138033/17171 +- sec61b_hipsc_train/42/138033/17255 +- sec61b_hipsc_train/42/138037/15612 +- sec61b_hipsc_train/42/138037/16696 +- sec61b_hipsc_train/42/138037/17203 +- sec61b_hipsc_train/42/138037/17223 +- sec61b_hipsc_train/42/138044/15587 +- sec61b_hipsc_train/42/138044/16757 +- sec61b_hipsc_train/42/138044/17236 +- sec61b_hipsc_train/42/138045/15540 +- sec61b_hipsc_train/42/138045/15558 +- sec61b_hipsc_train/42/138045/15684 +- sec61b_hipsc_train/42/138045/15786 +- sec61b_hipsc_train/42/138045/16126 +- sec61b_hipsc_train/42/138045/16159 +- sec61b_hipsc_train/42/138045/16598 +- sec61b_hipsc_train/42/138045/17164 +- sec61b_hipsc_train/42/138045/17234 +- sec61b_hipsc_train/42/138045/17242 +- sec61b_hipsc_train/42/138045/17256 +- sec61b_hipsc_train/42/138247/17207 +- sec61b_hipsc_train/42/138249/16356 +- sec61b_hipsc_train/42/138249/17200 +- sec61b_hipsc_train/42/138251/15688 +- sec61b_hipsc_train/42/138251/15760 +- sec61b_hipsc_train/42/138251/15918 +- sec61b_hipsc_train/42/138251/16722 +- sec61b_hipsc_train/42/138251/16982 +- sec61b_hipsc_train/42/138251/17191 +- sec61b_hipsc_train/42/138253/15957 +- sec61b_hipsc_train/42/138253/16263 +- sec61b_hipsc_train/42/138253/16587 +- sec61b_hipsc_train/42/138253/16799 +- sec61b_hipsc_train/42/138253/16955 +- sec61b_hipsc_train/42/138257/16247 +- sec61b_hipsc_train/42/138257/16292 +- sec61b_hipsc_train/42/138257/16306 +- sec61b_hipsc_train/42/138257/16480 +- sec61b_hipsc_train/42/138257/17221 +- sec61b_hipsc_train/42/138261/15887 +- sec61b_hipsc_train/42/138261/16083 +- sec61b_hipsc_train/42/138261/16860 +test_fovs: +- sec61b_hipsc_test/4/38452/5187 +- sec61b_hipsc_test/4/38452/5201 +- sec61b_hipsc_test/4/38452/5203 +- sec61b_hipsc_test/4/38464/5173 +- sec61b_hipsc_test/4/38465/5189 +- sec61b_hipsc_test/4/38466/5200 +- sec61b_hipsc_test/4/39124/5286 +- sec61b_hipsc_test/4/39125/5224 +- sec61b_hipsc_test/4/39126/5289 +- sec61b_hipsc_test/4/39128/5230 +- sec61b_hipsc_test/4/39128/5254 +- sec61b_hipsc_test/4/39137/5252 +- sec61b_hipsc_test/4/39138/5268 +- sec61b_hipsc_test/4/39140/5293 +- sec61b_hipsc_test/4/39222/5281 +- sec61b_hipsc_test/4/39222/5311 +- sec61b_hipsc_test/4/39232/5329 +- sec61b_hipsc_test/4/39233/5304 +- sec61b_hipsc_test/4/39233/5313 +- sec61b_hipsc_test/4/39233/5327 +- sec61b_hipsc_test/4/39236/5305 +- sec61b_hipsc_test/4/40084/5357 +- sec61b_hipsc_test/4/40084/5415 +- sec61b_hipsc_test/4/40085/5421 +- sec61b_hipsc_test/4/40086/5362 +- sec61b_hipsc_test/4/40181/5434 +- sec61b_hipsc_test/4/40181/5451 +- sec61b_hipsc_test/4/40181/5453 +- sec61b_hipsc_test/4/40195/5479 +- sec61b_hipsc_test/4/40196/5471 +- sec61b_hipsc_test/4/40375/4612 +- sec61b_hipsc_test/4/40376/4568 +- sec61b_hipsc_test/4/40376/4601 +- sec61b_hipsc_test/4/40376/4604 +- sec61b_hipsc_test/4/40385/4565 +- sec61b_hipsc_test/4/40385/4572 +- sec61b_hipsc_test/4/40385/4576 +- sec61b_hipsc_test/4/40385/4610 +- sec61b_hipsc_test/4/40386/4603 +- sec61b_hipsc_test/4/40386/4606 +- sec61b_hipsc_test/4/40387/4570 +- sec61b_hipsc_test/4/40388/4591 +- sec61b_hipsc_test/4/40468/4624 +- sec61b_hipsc_test/4/40471/4659 +- sec61b_hipsc_test/4/40471/4661 +- sec61b_hipsc_test/4/40471/4679 +- sec61b_hipsc_test/4/40481/4627 +- sec61b_hipsc_test/4/40483/4621 +- sec61b_hipsc_test/4/40483/4637 +- sec61b_hipsc_test/4/40483/4644 +- sec61b_hipsc_test/4/40960/4630 +- sec61b_hipsc_test/4/40961/4665 +- sec61b_hipsc_test/4/40964/4643 +- sec61b_hipsc_test/4/41044/4869 +- sec61b_hipsc_test/4/41044/4891 +- sec61b_hipsc_test/4/41046/4849 +- sec61b_hipsc_test/4/41047/4885 +- sec61b_hipsc_test/4/41057/4887 +- sec61b_hipsc_test/4/41059/4886 +- sec61b_hipsc_test/4/41060/4901 +- sec61b_hipsc_test/4/41238/4828 +- sec61b_hipsc_test/4/41239/4823 +- sec61b_hipsc_test/4/41239/4832 +- sec61b_hipsc_test/4/41240/4818 +- sec61b_hipsc_test/4/41240/4834 +- sec61b_hipsc_test/4/41335/4803 +- sec61b_hipsc_test/4/41348/4809 +- sec61b_hipsc_test/4/41428/4713 +- sec61b_hipsc_test/4/41428/4718 +- sec61b_hipsc_test/4/41428/4743 +- sec61b_hipsc_test/4/41430/4744 +- sec61b_hipsc_test/4/41432/4729 +- sec61b_hipsc_test/4/41441/4725 +- sec61b_hipsc_test/4/41908/5037 +- sec61b_hipsc_test/4/41908/5061 +- sec61b_hipsc_test/4/41909/5071 +- sec61b_hipsc_test/4/41910/5031 +- sec61b_hipsc_test/4/41910/5058 +- sec61b_hipsc_test/4/41910/5088 +- sec61b_hipsc_test/4/41911/5027 +- sec61b_hipsc_test/4/42199/5048 +- sec61b_hipsc_test/4/42211/5034 +- sec61b_hipsc_test/42/136118/14223 +- sec61b_hipsc_test/42/136118/14225 +- sec61b_hipsc_test/42/136118/16503 +- sec61b_hipsc_test/42/136119/16504 +- sec61b_hipsc_test/42/136120/14221 +- sec61b_hipsc_test/42/136120/14224 +- sec61b_hipsc_test/42/136120/14228 +- sec61b_hipsc_test/42/136120/15747 +- sec61b_hipsc_test/42/136124/16127 +- sec61b_hipsc_test/42/138024/17222 +- sec61b_hipsc_test/42/138026/17232 +- sec61b_hipsc_test/42/138028/15839 +- sec61b_hipsc_test/42/138028/17202 +- sec61b_hipsc_test/42/138032/15577 +- sec61b_hipsc_test/42/138044/15777 +- sec61b_hipsc_test/42/138045/16692 +- sec61b_hipsc_test/42/138251/17249 +- sec61b_hipsc_test/42/138253/15966 diff --git a/applications/dynacell/configs/collections/virtual_staining/sec61b_joint_all_v1.yaml b/applications/dynacell/configs/collections/virtual_staining/sec61b_joint_all_v1.yaml new file mode 100644 index 000000000..20264e00e --- /dev/null +++ b/applications/dynacell/configs/collections/virtual_staining/sec61b_joint_all_v1.yaml @@ -0,0 +1,806 @@ +name: sec61b_joint_all_v1 +description: Joint frozen benchmark collection for target 'sec61b' across 5 source + datasets. Channels and FOV membership captured from the live train/test zarr stores + at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-24T19:29:05.345825+00:00' + created_by: Alex Kalinin +experiments: +- name: sec61b_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: SEC61B + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: sec61b_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/SEC61B.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: SEC61B + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: sec61b_a549_mantis_2024_10_31_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_10_31_A549_SEC61_ZIKV_DENV/train/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2024_10_31_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_10_31_A549_SEC61_ZIKV_DENV/test/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2024_11_07_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_07_A549_SEC61_DENV/train/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2024_11_07_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_07_A549_SEC61_DENV/test/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2025_07_24_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV/train/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2025_07_24_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV/test/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2025_08_26_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_08_26_A549_SEC61_TOMM20_ZIKV/train/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2025_08_26_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_08_26_A549_SEC61_TOMM20_ZIKV/test/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +train_fovs: +- sec61b_hipsc_train/4/38452/5161 +- sec61b_hipsc_train/4/38452/5165 +- sec61b_hipsc_train/4/38452/5177 +- sec61b_hipsc_train/4/38452/5184 +- sec61b_hipsc_train/4/38452/5194 +- sec61b_hipsc_train/4/38452/5198 +- sec61b_hipsc_train/4/38464/5157 +- sec61b_hipsc_train/4/38464/5159 +- sec61b_hipsc_train/4/38464/5176 +- sec61b_hipsc_train/4/38464/5179 +- sec61b_hipsc_train/4/38464/5181 +- sec61b_hipsc_train/4/38464/5186 +- sec61b_hipsc_train/4/38464/5190 +- sec61b_hipsc_train/4/38464/5199 +- sec61b_hipsc_train/4/38464/5202 +- sec61b_hipsc_train/4/38465/5164 +- sec61b_hipsc_train/4/38465/5171 +- sec61b_hipsc_train/4/38465/5191 +- sec61b_hipsc_train/4/38465/5195 +- sec61b_hipsc_train/4/38465/5197 +- sec61b_hipsc_train/4/38466/5155 +- sec61b_hipsc_train/4/38466/5168 +- sec61b_hipsc_train/4/38466/5188 +- sec61b_hipsc_train/4/38466/5192 +- sec61b_hipsc_train/4/38466/5193 +- sec61b_hipsc_train/4/38466/5196 +- sec61b_hipsc_train/4/39124/5221 +- sec61b_hipsc_train/4/39124/5223 +- sec61b_hipsc_train/4/39124/5247 +- sec61b_hipsc_train/4/39124/5258 +- sec61b_hipsc_train/4/39124/5280 +- sec61b_hipsc_train/4/39125/5264 +- sec61b_hipsc_train/4/39126/5229 +- sec61b_hipsc_train/4/39127/5283 +- sec61b_hipsc_train/4/39128/5219 +- sec61b_hipsc_train/4/39128/5260 +- sec61b_hipsc_train/4/39128/5272 +- sec61b_hipsc_train/4/39136/5225 +- sec61b_hipsc_train/4/39136/5234 +- sec61b_hipsc_train/4/39136/5236 +- sec61b_hipsc_train/4/39136/5239 +- sec61b_hipsc_train/4/39137/5243 +- sec61b_hipsc_train/4/39137/5266 +- sec61b_hipsc_train/4/39137/5274 +- sec61b_hipsc_train/4/39137/5277 +- sec61b_hipsc_train/4/39138/5256 +- sec61b_hipsc_train/4/39138/5262 +- sec61b_hipsc_train/4/39138/5270 +- sec61b_hipsc_train/4/39139/5220 +- sec61b_hipsc_train/4/39139/5244 +- sec61b_hipsc_train/4/39139/5249 +- sec61b_hipsc_train/4/39139/5250 +- sec61b_hipsc_train/4/39140/5222 +- sec61b_hipsc_train/4/39140/5232 +- sec61b_hipsc_train/4/39140/5240 +- sec61b_hipsc_train/4/39222/5288 +- sec61b_hipsc_train/4/39222/5291 +- sec61b_hipsc_train/4/39222/5298 +- sec61b_hipsc_train/4/39222/5303 +- sec61b_hipsc_train/4/39222/5324 +- sec61b_hipsc_train/4/39224/5294 +- sec61b_hipsc_train/4/39224/5302 +- sec61b_hipsc_train/4/39224/5307 +- sec61b_hipsc_train/4/39224/5321 +- sec61b_hipsc_train/4/39224/5326 +- sec61b_hipsc_train/4/39224/5332 +- sec61b_hipsc_train/4/39232/5278 +- sec61b_hipsc_train/4/39232/5318 +- sec61b_hipsc_train/4/39232/5323 +- sec61b_hipsc_train/4/39232/5330 +- sec61b_hipsc_train/4/39233/5299 +- sec61b_hipsc_train/4/39233/5309 +- sec61b_hipsc_train/4/39233/5322 +- sec61b_hipsc_train/4/39236/5316 +- sec61b_hipsc_train/4/39236/5317 +- sec61b_hipsc_train/4/40084/5359 +- sec61b_hipsc_train/4/40084/5380 +- sec61b_hipsc_train/4/40084/5407 +- sec61b_hipsc_train/4/40084/5429 +- sec61b_hipsc_train/4/40085/5371 +- sec61b_hipsc_train/4/40085/5383 +- sec61b_hipsc_train/4/40085/5389 +- sec61b_hipsc_train/4/40086/5401 +- sec61b_hipsc_train/4/40087/5377 +- sec61b_hipsc_train/4/40087/5405 +- sec61b_hipsc_train/4/40087/5428 +- sec61b_hipsc_train/4/40088/5365 +- sec61b_hipsc_train/4/40088/5368 +- sec61b_hipsc_train/4/40088/5392 +- sec61b_hipsc_train/4/40088/5398 +- sec61b_hipsc_train/4/40088/5403 +- sec61b_hipsc_train/4/40088/5417 +- sec61b_hipsc_train/4/40088/5422 +- sec61b_hipsc_train/4/40088/5424 +- sec61b_hipsc_train/4/40088/5430 +- sec61b_hipsc_train/4/40098/5386 +- sec61b_hipsc_train/4/40098/5409 +- sec61b_hipsc_train/4/40098/5427 +- sec61b_hipsc_train/4/40180/5447 +- sec61b_hipsc_train/4/40180/5461 +- sec61b_hipsc_train/4/40180/5475 +- sec61b_hipsc_train/4/40180/5497 +- sec61b_hipsc_train/4/40181/5435 +- sec61b_hipsc_train/4/40181/5441 +- sec61b_hipsc_train/4/40181/5443 +- sec61b_hipsc_train/4/40181/5481 +- sec61b_hipsc_train/4/40182/5432 +- sec61b_hipsc_train/4/40182/5433 +- sec61b_hipsc_train/4/40182/5455 +- sec61b_hipsc_train/4/40182/5498 +- sec61b_hipsc_train/4/40184/5439 +- sec61b_hipsc_train/4/40184/5457 +- sec61b_hipsc_train/4/40194/5459 +- sec61b_hipsc_train/4/40194/5463 +- sec61b_hipsc_train/4/40195/5436 +- sec61b_hipsc_train/4/40195/5483 +- sec61b_hipsc_train/4/40195/5489 +- sec61b_hipsc_train/4/40195/5491 +- sec61b_hipsc_train/4/40375/4566 +- sec61b_hipsc_train/4/40375/4599 +- sec61b_hipsc_train/4/40375/4608 +- sec61b_hipsc_train/4/40376/4563 +- sec61b_hipsc_train/4/40376/4584 +- sec61b_hipsc_train/4/40376/4605 +- sec61b_hipsc_train/4/40376/4607 +- sec61b_hipsc_train/4/40376/4609 +- sec61b_hipsc_train/4/40385/4557 +- sec61b_hipsc_train/4/40385/4559 +- sec61b_hipsc_train/4/40385/4578 +- sec61b_hipsc_train/4/40385/4593 +- sec61b_hipsc_train/4/40385/4614 +- sec61b_hipsc_train/4/40386/4580 +- sec61b_hipsc_train/4/40386/4611 +- sec61b_hipsc_train/4/40386/4613 +- sec61b_hipsc_train/4/40387/4561 +- sec61b_hipsc_train/4/40387/4582 +- sec61b_hipsc_train/4/40387/4586 +- sec61b_hipsc_train/4/40387/4595 +- sec61b_hipsc_train/4/40387/4597 +- sec61b_hipsc_train/4/40388/4574 +- sec61b_hipsc_train/4/40388/4588 +- sec61b_hipsc_train/4/40468/4620 +- sec61b_hipsc_train/4/40468/4650 +- sec61b_hipsc_train/4/40468/4653 +- sec61b_hipsc_train/4/40468/4655 +- sec61b_hipsc_train/4/40469/4641 +- sec61b_hipsc_train/4/40469/4666 +- sec61b_hipsc_train/4/40469/4673 +- sec61b_hipsc_train/4/40470/4615 +- sec61b_hipsc_train/4/40470/4616 +- sec61b_hipsc_train/4/40470/4671 +- sec61b_hipsc_train/4/40470/4675 +- sec61b_hipsc_train/4/40470/4677 +- sec61b_hipsc_train/4/40471/4632 +- sec61b_hipsc_train/4/40471/4657 +- sec61b_hipsc_train/4/40471/4664 +- sec61b_hipsc_train/4/40481/4622 +- sec61b_hipsc_train/4/40481/4633 +- sec61b_hipsc_train/4/40481/4647 +- sec61b_hipsc_train/4/40481/4668 +- sec61b_hipsc_train/4/40483/4617 +- sec61b_hipsc_train/4/40483/4619 +- sec61b_hipsc_train/4/40483/4629 +- sec61b_hipsc_train/4/40484/4618 +- sec61b_hipsc_train/4/40484/4626 +- sec61b_hipsc_train/4/40484/4663 +- sec61b_hipsc_train/4/40960/4625 +- sec61b_hipsc_train/4/40960/4628 +- sec61b_hipsc_train/4/40960/4640 +- sec61b_hipsc_train/4/40960/4654 +- sec61b_hipsc_train/4/40960/4656 +- sec61b_hipsc_train/4/40960/4674 +- sec61b_hipsc_train/4/40960/4678 +- sec61b_hipsc_train/4/40961/4635 +- sec61b_hipsc_train/4/40961/4669 +- sec61b_hipsc_train/4/40962/4676 +- sec61b_hipsc_train/4/40964/4623 +- sec61b_hipsc_train/4/40964/4631 +- sec61b_hipsc_train/4/40964/4649 +- sec61b_hipsc_train/4/40964/4660 +- sec61b_hipsc_train/4/40964/4667 +- sec61b_hipsc_train/4/40964/4672 +- sec61b_hipsc_train/4/41044/4843 +- sec61b_hipsc_train/4/41044/4847 +- sec61b_hipsc_train/4/41044/4851 +- sec61b_hipsc_train/4/41044/4876 +- sec61b_hipsc_train/4/41044/4895 +- sec61b_hipsc_train/4/41045/4853 +- sec61b_hipsc_train/4/41045/4873 +- sec61b_hipsc_train/4/41045/4889 +- sec61b_hipsc_train/4/41045/4893 +- sec61b_hipsc_train/4/41046/4900 +- sec61b_hipsc_train/4/41047/4845 +- sec61b_hipsc_train/4/41047/4882 +- sec61b_hipsc_train/4/41047/4883 +- sec61b_hipsc_train/4/41047/4902 +- sec61b_hipsc_train/4/41057/4860 +- sec61b_hipsc_train/4/41057/4864 +- sec61b_hipsc_train/4/41057/4875 +- sec61b_hipsc_train/4/41057/4877 +- sec61b_hipsc_train/4/41057/4896 +- sec61b_hipsc_train/4/41058/4855 +- sec61b_hipsc_train/4/41058/4879 +- sec61b_hipsc_train/4/41058/4897 +- sec61b_hipsc_train/4/41058/4899 +- sec61b_hipsc_train/4/41059/4841 +- sec61b_hipsc_train/4/41059/4867 +- sec61b_hipsc_train/4/41059/4884 +- sec61b_hipsc_train/4/41059/4888 +- sec61b_hipsc_train/4/41059/4890 +- sec61b_hipsc_train/4/41059/4892 +- sec61b_hipsc_train/4/41060/4859 +- sec61b_hipsc_train/4/41060/4862 +- sec61b_hipsc_train/4/41060/4878 +- sec61b_hipsc_train/4/41060/4880 +- sec61b_hipsc_train/4/41060/4881 +- sec61b_hipsc_train/4/41060/4894 +- sec61b_hipsc_train/4/41060/4898 +- sec61b_hipsc_train/4/41237/4813 +- sec61b_hipsc_train/4/41237/4826 +- sec61b_hipsc_train/4/41237/4840 +- sec61b_hipsc_train/4/41237/4842 +- sec61b_hipsc_train/4/41237/4861 +- sec61b_hipsc_train/4/41237/4865 +- sec61b_hipsc_train/4/41237/4870 +- sec61b_hipsc_train/4/41238/4815 +- sec61b_hipsc_train/4/41238/4816 +- sec61b_hipsc_train/4/41238/4819 +- sec61b_hipsc_train/4/41238/4827 +- sec61b_hipsc_train/4/41238/4839 +- sec61b_hipsc_train/4/41238/4844 +- sec61b_hipsc_train/4/41238/4874 +- sec61b_hipsc_train/4/41239/4817 +- sec61b_hipsc_train/4/41239/4824 +- sec61b_hipsc_train/4/41239/4830 +- sec61b_hipsc_train/4/41239/4833 +- sec61b_hipsc_train/4/41239/4836 +- sec61b_hipsc_train/4/41239/4838 +- sec61b_hipsc_train/4/41240/4814 +- sec61b_hipsc_train/4/41240/4820 +- sec61b_hipsc_train/4/41240/4821 +- sec61b_hipsc_train/4/41240/4825 +- sec61b_hipsc_train/4/41240/4831 +- sec61b_hipsc_train/4/41240/4852 +- sec61b_hipsc_train/4/41240/4858 +- sec61b_hipsc_train/4/41240/4866 +- sec61b_hipsc_train/4/41249/4835 +- sec61b_hipsc_train/4/41249/4837 +- sec61b_hipsc_train/4/41249/4868 +- sec61b_hipsc_train/4/41335/4810 +- sec61b_hipsc_train/4/41347/4804 +- sec61b_hipsc_train/4/41347/4808 +- sec61b_hipsc_train/4/41347/4812 +- sec61b_hipsc_train/4/41348/4805 +- sec61b_hipsc_train/4/41348/4806 +- sec61b_hipsc_train/4/41348/4807 +- sec61b_hipsc_train/4/41348/4811 +- sec61b_hipsc_train/4/41428/4714 +- sec61b_hipsc_train/4/41428/4723 +- sec61b_hipsc_train/4/41428/4737 +- sec61b_hipsc_train/4/41428/4739 +- sec61b_hipsc_train/4/41430/4722 +- sec61b_hipsc_train/4/41430/4732 +- sec61b_hipsc_train/4/41430/4733 +- sec61b_hipsc_train/4/41430/4741 +- sec61b_hipsc_train/4/41430/4742 +- sec61b_hipsc_train/4/41432/4716 +- sec61b_hipsc_train/4/41432/4719 +- sec61b_hipsc_train/4/41432/4720 +- sec61b_hipsc_train/4/41432/4724 +- sec61b_hipsc_train/4/41432/4726 +- sec61b_hipsc_train/4/41432/4740 +- sec61b_hipsc_train/4/41441/4721 +- sec61b_hipsc_train/4/41441/4727 +- sec61b_hipsc_train/4/41441/4728 +- sec61b_hipsc_train/4/41441/4731 +- sec61b_hipsc_train/4/41441/4734 +- sec61b_hipsc_train/4/41441/4735 +- sec61b_hipsc_train/4/41908/5019 +- sec61b_hipsc_train/4/41908/5021 +- sec61b_hipsc_train/4/41908/5043 +- sec61b_hipsc_train/4/41908/5098 +- sec61b_hipsc_train/4/41908/5099 +- sec61b_hipsc_train/4/41909/5025 +- sec61b_hipsc_train/4/41909/5035 +- sec61b_hipsc_train/4/41909/5046 +- sec61b_hipsc_train/4/41909/5082 +- sec61b_hipsc_train/4/41909/5084 +- sec61b_hipsc_train/4/41909/5092 +- sec61b_hipsc_train/4/41909/5096 +- sec61b_hipsc_train/4/41910/5017 +- sec61b_hipsc_train/4/41910/5023 +- sec61b_hipsc_train/4/41910/5033 +- sec61b_hipsc_train/4/41910/5093 +- sec61b_hipsc_train/4/41911/5015 +- sec61b_hipsc_train/4/41911/5029 +- sec61b_hipsc_train/4/41911/5055 +- sec61b_hipsc_train/4/41911/5064 +- sec61b_hipsc_train/4/41911/5079 +- sec61b_hipsc_train/4/41911/5080 +- sec61b_hipsc_train/4/41911/5086 +- sec61b_hipsc_train/4/41911/5094 +- sec61b_hipsc_train/4/41912/5039 +- sec61b_hipsc_train/4/41912/5041 +- sec61b_hipsc_train/4/41912/5052 +- sec61b_hipsc_train/4/41912/5074 +- sec61b_hipsc_train/4/41912/5095 +- sec61b_hipsc_train/4/42197/5020 +- sec61b_hipsc_train/4/42197/5026 +- sec61b_hipsc_train/4/42197/5030 +- sec61b_hipsc_train/4/42197/5036 +- sec61b_hipsc_train/4/42197/5075 +- sec61b_hipsc_train/4/42199/5032 +- sec61b_hipsc_train/4/42199/5045 +- sec61b_hipsc_train/4/42199/5063 +- sec61b_hipsc_train/4/42199/5066 +- sec61b_hipsc_train/4/42199/5069 +- sec61b_hipsc_train/4/42200/5016 +- sec61b_hipsc_train/4/42200/5028 +- sec61b_hipsc_train/4/42200/5038 +- sec61b_hipsc_train/4/42211/5018 +- sec61b_hipsc_train/4/42211/5024 +- sec61b_hipsc_train/4/42211/5051 +- sec61b_hipsc_train/4/42211/5053 +- sec61b_hipsc_train/4/42211/5057 +- sec61b_hipsc_train/42/136118/15182 +- sec61b_hipsc_train/42/136118/15269 +- sec61b_hipsc_train/42/136118/16846 +- sec61b_hipsc_train/42/136119/14226 +- sec61b_hipsc_train/42/136119/14227 +- sec61b_hipsc_train/42/136119/15430 +- sec61b_hipsc_train/42/136119/15573 +- sec61b_hipsc_train/42/136120/15452 +- sec61b_hipsc_train/42/136120/15958 +- sec61b_hipsc_train/42/136120/16873 +- sec61b_hipsc_train/42/136121/15700 +- sec61b_hipsc_train/42/136121/16618 +- sec61b_hipsc_train/42/136121/17149 +- sec61b_hipsc_train/42/136122/16832 +- sec61b_hipsc_train/42/136122/16883 +- sec61b_hipsc_train/42/136122/16987 +- sec61b_hipsc_train/42/136122/17182 +- sec61b_hipsc_train/42/136124/15667 +- sec61b_hipsc_train/42/136124/15715 +- sec61b_hipsc_train/42/136126/15932 +- sec61b_hipsc_train/42/136126/16322 +- sec61b_hipsc_train/42/138024/15523 +- sec61b_hipsc_train/42/138024/15890 +- sec61b_hipsc_train/42/138024/16225 +- sec61b_hipsc_train/42/138024/16287 +- sec61b_hipsc_train/42/138024/16991 +- sec61b_hipsc_train/42/138025/15979 +- sec61b_hipsc_train/42/138025/16227 +- sec61b_hipsc_train/42/138025/16897 +- sec61b_hipsc_train/42/138025/17204 +- sec61b_hipsc_train/42/138025/17241 +- sec61b_hipsc_train/42/138026/15744 +- sec61b_hipsc_train/42/138026/16036 +- sec61b_hipsc_train/42/138026/16240 +- sec61b_hipsc_train/42/138026/17153 +- sec61b_hipsc_train/42/138026/17201 +- sec61b_hipsc_train/42/138026/17206 +- sec61b_hipsc_train/42/138026/17257 +- sec61b_hipsc_train/42/138027/17190 +- sec61b_hipsc_train/42/138027/17231 +- sec61b_hipsc_train/42/138027/17262 +- sec61b_hipsc_train/42/138028/15886 +- sec61b_hipsc_train/42/138028/16174 +- sec61b_hipsc_train/42/138028/16396 +- sec61b_hipsc_train/42/138028/17142 +- sec61b_hipsc_train/42/138028/17192 +- sec61b_hipsc_train/42/138028/17244 +- sec61b_hipsc_train/42/138030/15632 +- sec61b_hipsc_train/42/138030/15792 +- sec61b_hipsc_train/42/138030/15894 +- sec61b_hipsc_train/42/138032/15614 +- sec61b_hipsc_train/42/138032/15851 +- sec61b_hipsc_train/42/138032/16266 +- sec61b_hipsc_train/42/138032/16928 +- sec61b_hipsc_train/42/138032/17205 +- sec61b_hipsc_train/42/138032/17209 +- sec61b_hipsc_train/42/138033/17171 +- sec61b_hipsc_train/42/138033/17255 +- sec61b_hipsc_train/42/138037/15612 +- sec61b_hipsc_train/42/138037/16696 +- sec61b_hipsc_train/42/138037/17203 +- sec61b_hipsc_train/42/138037/17223 +- sec61b_hipsc_train/42/138044/15587 +- sec61b_hipsc_train/42/138044/16757 +- sec61b_hipsc_train/42/138044/17236 +- sec61b_hipsc_train/42/138045/15540 +- sec61b_hipsc_train/42/138045/15558 +- sec61b_hipsc_train/42/138045/15684 +- sec61b_hipsc_train/42/138045/15786 +- sec61b_hipsc_train/42/138045/16126 +- sec61b_hipsc_train/42/138045/16159 +- sec61b_hipsc_train/42/138045/16598 +- sec61b_hipsc_train/42/138045/17164 +- sec61b_hipsc_train/42/138045/17234 +- sec61b_hipsc_train/42/138045/17242 +- sec61b_hipsc_train/42/138045/17256 +- sec61b_hipsc_train/42/138247/17207 +- sec61b_hipsc_train/42/138249/16356 +- sec61b_hipsc_train/42/138249/17200 +- sec61b_hipsc_train/42/138251/15688 +- sec61b_hipsc_train/42/138251/15760 +- sec61b_hipsc_train/42/138251/15918 +- sec61b_hipsc_train/42/138251/16722 +- sec61b_hipsc_train/42/138251/16982 +- sec61b_hipsc_train/42/138251/17191 +- sec61b_hipsc_train/42/138253/15957 +- sec61b_hipsc_train/42/138253/16263 +- sec61b_hipsc_train/42/138253/16587 +- sec61b_hipsc_train/42/138253/16799 +- sec61b_hipsc_train/42/138253/16955 +- sec61b_hipsc_train/42/138257/16247 +- sec61b_hipsc_train/42/138257/16292 +- sec61b_hipsc_train/42/138257/16306 +- sec61b_hipsc_train/42/138257/16480 +- sec61b_hipsc_train/42/138257/17221 +- sec61b_hipsc_train/42/138261/15887 +- sec61b_hipsc_train/42/138261/16083 +- sec61b_hipsc_train/42/138261/16860 +- sec61b_a549_mantis_2024_10_31_train/C/2/000000 +- sec61b_a549_mantis_2024_10_31_train/C/2/000001 +- sec61b_a549_mantis_2024_10_31_train/C/2/001000 +- sec61b_a549_mantis_2024_10_31_train/C/2/001001 +- sec61b_a549_mantis_2024_10_31_train/C/2/002000 +- sec61b_a549_mantis_2024_10_31_train/C/2/002001 +- sec61b_a549_mantis_2024_10_31_train/C/4/002000 +- sec61b_a549_mantis_2024_10_31_train/C/4/002001 +- sec61b_a549_mantis_2024_11_07_train/B/1/001000 +- sec61b_a549_mantis_2024_11_07_train/B/1/001001 +- sec61b_a549_mantis_2024_11_07_train/B/3/001000 +- sec61b_a549_mantis_2024_11_07_train/B/3/001001 +- sec61b_a549_mantis_2025_07_24_train/A/1/002000 +- sec61b_a549_mantis_2025_07_24_train/A/1/002001 +- sec61b_a549_mantis_2025_08_26_train/A/1/001001 +- sec61b_a549_mantis_2025_08_26_train/A/1/001002 +- sec61b_a549_mantis_2025_08_26_train/A/1/002000 +- sec61b_a549_mantis_2025_08_26_train/A/1/002001 +- sec61b_a549_mantis_2025_08_26_train/A/1/002002 +- sec61b_a549_mantis_2025_08_26_train/B/1/002000 +- sec61b_a549_mantis_2025_08_26_train/B/1/002001 +- sec61b_a549_mantis_2025_08_26_train/B/1/002002 +test_fovs: +- sec61b_hipsc_test/4/38452/5187 +- sec61b_hipsc_test/4/38452/5201 +- sec61b_hipsc_test/4/38452/5203 +- sec61b_hipsc_test/4/38464/5173 +- sec61b_hipsc_test/4/38465/5189 +- sec61b_hipsc_test/4/38466/5200 +- sec61b_hipsc_test/4/39124/5286 +- sec61b_hipsc_test/4/39125/5224 +- sec61b_hipsc_test/4/39126/5289 +- sec61b_hipsc_test/4/39128/5230 +- sec61b_hipsc_test/4/39128/5254 +- sec61b_hipsc_test/4/39137/5252 +- sec61b_hipsc_test/4/39138/5268 +- sec61b_hipsc_test/4/39140/5293 +- sec61b_hipsc_test/4/39222/5281 +- sec61b_hipsc_test/4/39222/5311 +- sec61b_hipsc_test/4/39232/5329 +- sec61b_hipsc_test/4/39233/5304 +- sec61b_hipsc_test/4/39233/5313 +- sec61b_hipsc_test/4/39233/5327 +- sec61b_hipsc_test/4/39236/5305 +- sec61b_hipsc_test/4/40084/5357 +- sec61b_hipsc_test/4/40084/5415 +- sec61b_hipsc_test/4/40085/5421 +- sec61b_hipsc_test/4/40086/5362 +- sec61b_hipsc_test/4/40181/5434 +- sec61b_hipsc_test/4/40181/5451 +- sec61b_hipsc_test/4/40181/5453 +- sec61b_hipsc_test/4/40195/5479 +- sec61b_hipsc_test/4/40196/5471 +- sec61b_hipsc_test/4/40375/4612 +- sec61b_hipsc_test/4/40376/4568 +- sec61b_hipsc_test/4/40376/4601 +- sec61b_hipsc_test/4/40376/4604 +- sec61b_hipsc_test/4/40385/4565 +- sec61b_hipsc_test/4/40385/4572 +- sec61b_hipsc_test/4/40385/4576 +- sec61b_hipsc_test/4/40385/4610 +- sec61b_hipsc_test/4/40386/4603 +- sec61b_hipsc_test/4/40386/4606 +- sec61b_hipsc_test/4/40387/4570 +- sec61b_hipsc_test/4/40388/4591 +- sec61b_hipsc_test/4/40468/4624 +- sec61b_hipsc_test/4/40471/4659 +- sec61b_hipsc_test/4/40471/4661 +- sec61b_hipsc_test/4/40471/4679 +- sec61b_hipsc_test/4/40481/4627 +- sec61b_hipsc_test/4/40483/4621 +- sec61b_hipsc_test/4/40483/4637 +- sec61b_hipsc_test/4/40483/4644 +- sec61b_hipsc_test/4/40960/4630 +- sec61b_hipsc_test/4/40961/4665 +- sec61b_hipsc_test/4/40964/4643 +- sec61b_hipsc_test/4/41044/4869 +- sec61b_hipsc_test/4/41044/4891 +- sec61b_hipsc_test/4/41046/4849 +- sec61b_hipsc_test/4/41047/4885 +- sec61b_hipsc_test/4/41057/4887 +- sec61b_hipsc_test/4/41059/4886 +- sec61b_hipsc_test/4/41060/4901 +- sec61b_hipsc_test/4/41238/4828 +- sec61b_hipsc_test/4/41239/4823 +- sec61b_hipsc_test/4/41239/4832 +- sec61b_hipsc_test/4/41240/4818 +- sec61b_hipsc_test/4/41240/4834 +- sec61b_hipsc_test/4/41335/4803 +- sec61b_hipsc_test/4/41348/4809 +- sec61b_hipsc_test/4/41428/4713 +- sec61b_hipsc_test/4/41428/4718 +- sec61b_hipsc_test/4/41428/4743 +- sec61b_hipsc_test/4/41430/4744 +- sec61b_hipsc_test/4/41432/4729 +- sec61b_hipsc_test/4/41441/4725 +- sec61b_hipsc_test/4/41908/5037 +- sec61b_hipsc_test/4/41908/5061 +- sec61b_hipsc_test/4/41909/5071 +- sec61b_hipsc_test/4/41910/5031 +- sec61b_hipsc_test/4/41910/5058 +- sec61b_hipsc_test/4/41910/5088 +- sec61b_hipsc_test/4/41911/5027 +- sec61b_hipsc_test/4/42199/5048 +- sec61b_hipsc_test/4/42211/5034 +- sec61b_hipsc_test/42/136118/14223 +- sec61b_hipsc_test/42/136118/14225 +- sec61b_hipsc_test/42/136118/16503 +- sec61b_hipsc_test/42/136119/16504 +- sec61b_hipsc_test/42/136120/14221 +- sec61b_hipsc_test/42/136120/14224 +- sec61b_hipsc_test/42/136120/14228 +- sec61b_hipsc_test/42/136120/15747 +- sec61b_hipsc_test/42/136124/16127 +- sec61b_hipsc_test/42/138024/17222 +- sec61b_hipsc_test/42/138026/17232 +- sec61b_hipsc_test/42/138028/15839 +- sec61b_hipsc_test/42/138028/17202 +- sec61b_hipsc_test/42/138032/15577 +- sec61b_hipsc_test/42/138044/15777 +- sec61b_hipsc_test/42/138045/16692 +- sec61b_hipsc_test/42/138251/17249 +- sec61b_hipsc_test/42/138253/15966 +- sec61b_a549_mantis_2024_10_31_test/C/4/000000 +- sec61b_a549_mantis_2024_10_31_test/C/4/000001 +- sec61b_a549_mantis_2024_10_31_test/C/4/001000 +- sec61b_a549_mantis_2024_10_31_test/C/4/001001 +- sec61b_a549_mantis_2024_11_07_test/B/1/000000 +- sec61b_a549_mantis_2024_11_07_test/B/1/000001 +- sec61b_a549_mantis_2024_11_07_test/B/2/000000 +- sec61b_a549_mantis_2024_11_07_test/B/2/000001 +- sec61b_a549_mantis_2024_11_07_test/B/2/001000 +- sec61b_a549_mantis_2024_11_07_test/B/2/001001 +- sec61b_a549_mantis_2024_11_07_test/B/3/000000 +- sec61b_a549_mantis_2024_11_07_test/B/3/000001 +- sec61b_a549_mantis_2024_11_07_test/C/2/000000 +- sec61b_a549_mantis_2024_11_07_test/C/2/000001 +- sec61b_a549_mantis_2024_11_07_test/C/2/001000 +- sec61b_a549_mantis_2024_11_07_test/C/2/001001 +- sec61b_a549_mantis_2025_07_24_test/A/1/000000 +- sec61b_a549_mantis_2025_07_24_test/A/1/000001 +- sec61b_a549_mantis_2025_07_24_test/A/1/001000 +- sec61b_a549_mantis_2025_07_24_test/A/1/001001 +- sec61b_a549_mantis_2025_07_24_test/A/2/000000 +- sec61b_a549_mantis_2025_07_24_test/A/2/000001 +- sec61b_a549_mantis_2025_07_24_test/A/2/001000 +- sec61b_a549_mantis_2025_07_24_test/A/2/001001 +- sec61b_a549_mantis_2025_07_24_test/A/2/002000 +- sec61b_a549_mantis_2025_07_24_test/A/2/002001 +- sec61b_a549_mantis_2025_08_26_test/A/1/000000 +- sec61b_a549_mantis_2025_08_26_test/A/1/000001 +- sec61b_a549_mantis_2025_08_26_test/A/1/000002 +- sec61b_a549_mantis_2025_08_26_test/A/1/001000 +- sec61b_a549_mantis_2025_08_26_test/B/1/000000 +- sec61b_a549_mantis_2025_08_26_test/B/1/000001 +- sec61b_a549_mantis_2025_08_26_test/B/1/000002 +- sec61b_a549_mantis_2025_08_26_test/B/1/001000 +- sec61b_a549_mantis_2025_08_26_test/B/1/001001 +- sec61b_a549_mantis_2025_08_26_test/B/1/001002 diff --git a/applications/dynacell/configs/collections/virtual_staining/sec61b_joint_mock_v1.yaml b/applications/dynacell/configs/collections/virtual_staining/sec61b_joint_mock_v1.yaml new file mode 100644 index 000000000..24f70cd76 --- /dev/null +++ b/applications/dynacell/configs/collections/virtual_staining/sec61b_joint_mock_v1.yaml @@ -0,0 +1,731 @@ +name: sec61b_joint_mock_v1 +description: Joint frozen benchmark collection for target 'sec61b' with condition + filter 'mock' across 4 source datasets. Channels and FOV membership captured from + the live train/test zarr stores at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-24T19:47:08.661967+00:00' + created_by: Alex Kalinin +experiments: +- name: sec61b_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: SEC61B + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: sec61b_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/SEC61B.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: SEC61B + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: sec61b_a549_mantis_2024_11_07_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_07_A549_SEC61_DENV/train/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2024_11_07_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_07_A549_SEC61_DENV/test/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2025_07_24_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV/train/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2025_07_24_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV/test/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2025_08_26_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_08_26_A549_SEC61_TOMM20_ZIKV/train/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2025_08_26_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_08_26_A549_SEC61_TOMM20_ZIKV/test/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +train_fovs: +- sec61b_hipsc_train/4/38452/5161 +- sec61b_hipsc_train/4/38452/5165 +- sec61b_hipsc_train/4/38452/5177 +- sec61b_hipsc_train/4/38452/5184 +- sec61b_hipsc_train/4/38452/5194 +- sec61b_hipsc_train/4/38452/5198 +- sec61b_hipsc_train/4/38464/5157 +- sec61b_hipsc_train/4/38464/5159 +- sec61b_hipsc_train/4/38464/5176 +- sec61b_hipsc_train/4/38464/5179 +- sec61b_hipsc_train/4/38464/5181 +- sec61b_hipsc_train/4/38464/5186 +- sec61b_hipsc_train/4/38464/5190 +- sec61b_hipsc_train/4/38464/5199 +- sec61b_hipsc_train/4/38464/5202 +- sec61b_hipsc_train/4/38465/5164 +- sec61b_hipsc_train/4/38465/5171 +- sec61b_hipsc_train/4/38465/5191 +- sec61b_hipsc_train/4/38465/5195 +- sec61b_hipsc_train/4/38465/5197 +- sec61b_hipsc_train/4/38466/5155 +- sec61b_hipsc_train/4/38466/5168 +- sec61b_hipsc_train/4/38466/5188 +- sec61b_hipsc_train/4/38466/5192 +- sec61b_hipsc_train/4/38466/5193 +- sec61b_hipsc_train/4/38466/5196 +- sec61b_hipsc_train/4/39124/5221 +- sec61b_hipsc_train/4/39124/5223 +- sec61b_hipsc_train/4/39124/5247 +- sec61b_hipsc_train/4/39124/5258 +- sec61b_hipsc_train/4/39124/5280 +- sec61b_hipsc_train/4/39125/5264 +- sec61b_hipsc_train/4/39126/5229 +- sec61b_hipsc_train/4/39127/5283 +- sec61b_hipsc_train/4/39128/5219 +- sec61b_hipsc_train/4/39128/5260 +- sec61b_hipsc_train/4/39128/5272 +- sec61b_hipsc_train/4/39136/5225 +- sec61b_hipsc_train/4/39136/5234 +- sec61b_hipsc_train/4/39136/5236 +- sec61b_hipsc_train/4/39136/5239 +- sec61b_hipsc_train/4/39137/5243 +- sec61b_hipsc_train/4/39137/5266 +- sec61b_hipsc_train/4/39137/5274 +- sec61b_hipsc_train/4/39137/5277 +- sec61b_hipsc_train/4/39138/5256 +- sec61b_hipsc_train/4/39138/5262 +- sec61b_hipsc_train/4/39138/5270 +- sec61b_hipsc_train/4/39139/5220 +- sec61b_hipsc_train/4/39139/5244 +- sec61b_hipsc_train/4/39139/5249 +- sec61b_hipsc_train/4/39139/5250 +- sec61b_hipsc_train/4/39140/5222 +- sec61b_hipsc_train/4/39140/5232 +- sec61b_hipsc_train/4/39140/5240 +- sec61b_hipsc_train/4/39222/5288 +- sec61b_hipsc_train/4/39222/5291 +- sec61b_hipsc_train/4/39222/5298 +- sec61b_hipsc_train/4/39222/5303 +- sec61b_hipsc_train/4/39222/5324 +- sec61b_hipsc_train/4/39224/5294 +- sec61b_hipsc_train/4/39224/5302 +- sec61b_hipsc_train/4/39224/5307 +- sec61b_hipsc_train/4/39224/5321 +- sec61b_hipsc_train/4/39224/5326 +- sec61b_hipsc_train/4/39224/5332 +- sec61b_hipsc_train/4/39232/5278 +- sec61b_hipsc_train/4/39232/5318 +- sec61b_hipsc_train/4/39232/5323 +- sec61b_hipsc_train/4/39232/5330 +- sec61b_hipsc_train/4/39233/5299 +- sec61b_hipsc_train/4/39233/5309 +- sec61b_hipsc_train/4/39233/5322 +- sec61b_hipsc_train/4/39236/5316 +- sec61b_hipsc_train/4/39236/5317 +- sec61b_hipsc_train/4/40084/5359 +- sec61b_hipsc_train/4/40084/5380 +- sec61b_hipsc_train/4/40084/5407 +- sec61b_hipsc_train/4/40084/5429 +- sec61b_hipsc_train/4/40085/5371 +- sec61b_hipsc_train/4/40085/5383 +- sec61b_hipsc_train/4/40085/5389 +- sec61b_hipsc_train/4/40086/5401 +- sec61b_hipsc_train/4/40087/5377 +- sec61b_hipsc_train/4/40087/5405 +- sec61b_hipsc_train/4/40087/5428 +- sec61b_hipsc_train/4/40088/5365 +- sec61b_hipsc_train/4/40088/5368 +- sec61b_hipsc_train/4/40088/5392 +- sec61b_hipsc_train/4/40088/5398 +- sec61b_hipsc_train/4/40088/5403 +- sec61b_hipsc_train/4/40088/5417 +- sec61b_hipsc_train/4/40088/5422 +- sec61b_hipsc_train/4/40088/5424 +- sec61b_hipsc_train/4/40088/5430 +- sec61b_hipsc_train/4/40098/5386 +- sec61b_hipsc_train/4/40098/5409 +- sec61b_hipsc_train/4/40098/5427 +- sec61b_hipsc_train/4/40180/5447 +- sec61b_hipsc_train/4/40180/5461 +- sec61b_hipsc_train/4/40180/5475 +- sec61b_hipsc_train/4/40180/5497 +- sec61b_hipsc_train/4/40181/5435 +- sec61b_hipsc_train/4/40181/5441 +- sec61b_hipsc_train/4/40181/5443 +- sec61b_hipsc_train/4/40181/5481 +- sec61b_hipsc_train/4/40182/5432 +- sec61b_hipsc_train/4/40182/5433 +- sec61b_hipsc_train/4/40182/5455 +- sec61b_hipsc_train/4/40182/5498 +- sec61b_hipsc_train/4/40184/5439 +- sec61b_hipsc_train/4/40184/5457 +- sec61b_hipsc_train/4/40194/5459 +- sec61b_hipsc_train/4/40194/5463 +- sec61b_hipsc_train/4/40195/5436 +- sec61b_hipsc_train/4/40195/5483 +- sec61b_hipsc_train/4/40195/5489 +- sec61b_hipsc_train/4/40195/5491 +- sec61b_hipsc_train/4/40375/4566 +- sec61b_hipsc_train/4/40375/4599 +- sec61b_hipsc_train/4/40375/4608 +- sec61b_hipsc_train/4/40376/4563 +- sec61b_hipsc_train/4/40376/4584 +- sec61b_hipsc_train/4/40376/4605 +- sec61b_hipsc_train/4/40376/4607 +- sec61b_hipsc_train/4/40376/4609 +- sec61b_hipsc_train/4/40385/4557 +- sec61b_hipsc_train/4/40385/4559 +- sec61b_hipsc_train/4/40385/4578 +- sec61b_hipsc_train/4/40385/4593 +- sec61b_hipsc_train/4/40385/4614 +- sec61b_hipsc_train/4/40386/4580 +- sec61b_hipsc_train/4/40386/4611 +- sec61b_hipsc_train/4/40386/4613 +- sec61b_hipsc_train/4/40387/4561 +- sec61b_hipsc_train/4/40387/4582 +- sec61b_hipsc_train/4/40387/4586 +- sec61b_hipsc_train/4/40387/4595 +- sec61b_hipsc_train/4/40387/4597 +- sec61b_hipsc_train/4/40388/4574 +- sec61b_hipsc_train/4/40388/4588 +- sec61b_hipsc_train/4/40468/4620 +- sec61b_hipsc_train/4/40468/4650 +- sec61b_hipsc_train/4/40468/4653 +- sec61b_hipsc_train/4/40468/4655 +- sec61b_hipsc_train/4/40469/4641 +- sec61b_hipsc_train/4/40469/4666 +- sec61b_hipsc_train/4/40469/4673 +- sec61b_hipsc_train/4/40470/4615 +- sec61b_hipsc_train/4/40470/4616 +- sec61b_hipsc_train/4/40470/4671 +- sec61b_hipsc_train/4/40470/4675 +- sec61b_hipsc_train/4/40470/4677 +- sec61b_hipsc_train/4/40471/4632 +- sec61b_hipsc_train/4/40471/4657 +- sec61b_hipsc_train/4/40471/4664 +- sec61b_hipsc_train/4/40481/4622 +- sec61b_hipsc_train/4/40481/4633 +- sec61b_hipsc_train/4/40481/4647 +- sec61b_hipsc_train/4/40481/4668 +- sec61b_hipsc_train/4/40483/4617 +- sec61b_hipsc_train/4/40483/4619 +- sec61b_hipsc_train/4/40483/4629 +- sec61b_hipsc_train/4/40484/4618 +- sec61b_hipsc_train/4/40484/4626 +- sec61b_hipsc_train/4/40484/4663 +- sec61b_hipsc_train/4/40960/4625 +- sec61b_hipsc_train/4/40960/4628 +- sec61b_hipsc_train/4/40960/4640 +- sec61b_hipsc_train/4/40960/4654 +- sec61b_hipsc_train/4/40960/4656 +- sec61b_hipsc_train/4/40960/4674 +- sec61b_hipsc_train/4/40960/4678 +- sec61b_hipsc_train/4/40961/4635 +- sec61b_hipsc_train/4/40961/4669 +- sec61b_hipsc_train/4/40962/4676 +- sec61b_hipsc_train/4/40964/4623 +- sec61b_hipsc_train/4/40964/4631 +- sec61b_hipsc_train/4/40964/4649 +- sec61b_hipsc_train/4/40964/4660 +- sec61b_hipsc_train/4/40964/4667 +- sec61b_hipsc_train/4/40964/4672 +- sec61b_hipsc_train/4/41044/4843 +- sec61b_hipsc_train/4/41044/4847 +- sec61b_hipsc_train/4/41044/4851 +- sec61b_hipsc_train/4/41044/4876 +- sec61b_hipsc_train/4/41044/4895 +- sec61b_hipsc_train/4/41045/4853 +- sec61b_hipsc_train/4/41045/4873 +- sec61b_hipsc_train/4/41045/4889 +- sec61b_hipsc_train/4/41045/4893 +- sec61b_hipsc_train/4/41046/4900 +- sec61b_hipsc_train/4/41047/4845 +- sec61b_hipsc_train/4/41047/4882 +- sec61b_hipsc_train/4/41047/4883 +- sec61b_hipsc_train/4/41047/4902 +- sec61b_hipsc_train/4/41057/4860 +- sec61b_hipsc_train/4/41057/4864 +- sec61b_hipsc_train/4/41057/4875 +- sec61b_hipsc_train/4/41057/4877 +- sec61b_hipsc_train/4/41057/4896 +- sec61b_hipsc_train/4/41058/4855 +- sec61b_hipsc_train/4/41058/4879 +- sec61b_hipsc_train/4/41058/4897 +- sec61b_hipsc_train/4/41058/4899 +- sec61b_hipsc_train/4/41059/4841 +- sec61b_hipsc_train/4/41059/4867 +- sec61b_hipsc_train/4/41059/4884 +- sec61b_hipsc_train/4/41059/4888 +- sec61b_hipsc_train/4/41059/4890 +- sec61b_hipsc_train/4/41059/4892 +- sec61b_hipsc_train/4/41060/4859 +- sec61b_hipsc_train/4/41060/4862 +- sec61b_hipsc_train/4/41060/4878 +- sec61b_hipsc_train/4/41060/4880 +- sec61b_hipsc_train/4/41060/4881 +- sec61b_hipsc_train/4/41060/4894 +- sec61b_hipsc_train/4/41060/4898 +- sec61b_hipsc_train/4/41237/4813 +- sec61b_hipsc_train/4/41237/4826 +- sec61b_hipsc_train/4/41237/4840 +- sec61b_hipsc_train/4/41237/4842 +- sec61b_hipsc_train/4/41237/4861 +- sec61b_hipsc_train/4/41237/4865 +- sec61b_hipsc_train/4/41237/4870 +- sec61b_hipsc_train/4/41238/4815 +- sec61b_hipsc_train/4/41238/4816 +- sec61b_hipsc_train/4/41238/4819 +- sec61b_hipsc_train/4/41238/4827 +- sec61b_hipsc_train/4/41238/4839 +- sec61b_hipsc_train/4/41238/4844 +- sec61b_hipsc_train/4/41238/4874 +- sec61b_hipsc_train/4/41239/4817 +- sec61b_hipsc_train/4/41239/4824 +- sec61b_hipsc_train/4/41239/4830 +- sec61b_hipsc_train/4/41239/4833 +- sec61b_hipsc_train/4/41239/4836 +- sec61b_hipsc_train/4/41239/4838 +- sec61b_hipsc_train/4/41240/4814 +- sec61b_hipsc_train/4/41240/4820 +- sec61b_hipsc_train/4/41240/4821 +- sec61b_hipsc_train/4/41240/4825 +- sec61b_hipsc_train/4/41240/4831 +- sec61b_hipsc_train/4/41240/4852 +- sec61b_hipsc_train/4/41240/4858 +- sec61b_hipsc_train/4/41240/4866 +- sec61b_hipsc_train/4/41249/4835 +- sec61b_hipsc_train/4/41249/4837 +- sec61b_hipsc_train/4/41249/4868 +- sec61b_hipsc_train/4/41335/4810 +- sec61b_hipsc_train/4/41347/4804 +- sec61b_hipsc_train/4/41347/4808 +- sec61b_hipsc_train/4/41347/4812 +- sec61b_hipsc_train/4/41348/4805 +- sec61b_hipsc_train/4/41348/4806 +- sec61b_hipsc_train/4/41348/4807 +- sec61b_hipsc_train/4/41348/4811 +- sec61b_hipsc_train/4/41428/4714 +- sec61b_hipsc_train/4/41428/4723 +- sec61b_hipsc_train/4/41428/4737 +- sec61b_hipsc_train/4/41428/4739 +- sec61b_hipsc_train/4/41430/4722 +- sec61b_hipsc_train/4/41430/4732 +- sec61b_hipsc_train/4/41430/4733 +- sec61b_hipsc_train/4/41430/4741 +- sec61b_hipsc_train/4/41430/4742 +- sec61b_hipsc_train/4/41432/4716 +- sec61b_hipsc_train/4/41432/4719 +- sec61b_hipsc_train/4/41432/4720 +- sec61b_hipsc_train/4/41432/4724 +- sec61b_hipsc_train/4/41432/4726 +- sec61b_hipsc_train/4/41432/4740 +- sec61b_hipsc_train/4/41441/4721 +- sec61b_hipsc_train/4/41441/4727 +- sec61b_hipsc_train/4/41441/4728 +- sec61b_hipsc_train/4/41441/4731 +- sec61b_hipsc_train/4/41441/4734 +- sec61b_hipsc_train/4/41441/4735 +- sec61b_hipsc_train/4/41908/5019 +- sec61b_hipsc_train/4/41908/5021 +- sec61b_hipsc_train/4/41908/5043 +- sec61b_hipsc_train/4/41908/5098 +- sec61b_hipsc_train/4/41908/5099 +- sec61b_hipsc_train/4/41909/5025 +- sec61b_hipsc_train/4/41909/5035 +- sec61b_hipsc_train/4/41909/5046 +- sec61b_hipsc_train/4/41909/5082 +- sec61b_hipsc_train/4/41909/5084 +- sec61b_hipsc_train/4/41909/5092 +- sec61b_hipsc_train/4/41909/5096 +- sec61b_hipsc_train/4/41910/5017 +- sec61b_hipsc_train/4/41910/5023 +- sec61b_hipsc_train/4/41910/5033 +- sec61b_hipsc_train/4/41910/5093 +- sec61b_hipsc_train/4/41911/5015 +- sec61b_hipsc_train/4/41911/5029 +- sec61b_hipsc_train/4/41911/5055 +- sec61b_hipsc_train/4/41911/5064 +- sec61b_hipsc_train/4/41911/5079 +- sec61b_hipsc_train/4/41911/5080 +- sec61b_hipsc_train/4/41911/5086 +- sec61b_hipsc_train/4/41911/5094 +- sec61b_hipsc_train/4/41912/5039 +- sec61b_hipsc_train/4/41912/5041 +- sec61b_hipsc_train/4/41912/5052 +- sec61b_hipsc_train/4/41912/5074 +- sec61b_hipsc_train/4/41912/5095 +- sec61b_hipsc_train/4/42197/5020 +- sec61b_hipsc_train/4/42197/5026 +- sec61b_hipsc_train/4/42197/5030 +- sec61b_hipsc_train/4/42197/5036 +- sec61b_hipsc_train/4/42197/5075 +- sec61b_hipsc_train/4/42199/5032 +- sec61b_hipsc_train/4/42199/5045 +- sec61b_hipsc_train/4/42199/5063 +- sec61b_hipsc_train/4/42199/5066 +- sec61b_hipsc_train/4/42199/5069 +- sec61b_hipsc_train/4/42200/5016 +- sec61b_hipsc_train/4/42200/5028 +- sec61b_hipsc_train/4/42200/5038 +- sec61b_hipsc_train/4/42211/5018 +- sec61b_hipsc_train/4/42211/5024 +- sec61b_hipsc_train/4/42211/5051 +- sec61b_hipsc_train/4/42211/5053 +- sec61b_hipsc_train/4/42211/5057 +- sec61b_hipsc_train/42/136118/15182 +- sec61b_hipsc_train/42/136118/15269 +- sec61b_hipsc_train/42/136118/16846 +- sec61b_hipsc_train/42/136119/14226 +- sec61b_hipsc_train/42/136119/14227 +- sec61b_hipsc_train/42/136119/15430 +- sec61b_hipsc_train/42/136119/15573 +- sec61b_hipsc_train/42/136120/15452 +- sec61b_hipsc_train/42/136120/15958 +- sec61b_hipsc_train/42/136120/16873 +- sec61b_hipsc_train/42/136121/15700 +- sec61b_hipsc_train/42/136121/16618 +- sec61b_hipsc_train/42/136121/17149 +- sec61b_hipsc_train/42/136122/16832 +- sec61b_hipsc_train/42/136122/16883 +- sec61b_hipsc_train/42/136122/16987 +- sec61b_hipsc_train/42/136122/17182 +- sec61b_hipsc_train/42/136124/15667 +- sec61b_hipsc_train/42/136124/15715 +- sec61b_hipsc_train/42/136126/15932 +- sec61b_hipsc_train/42/136126/16322 +- sec61b_hipsc_train/42/138024/15523 +- sec61b_hipsc_train/42/138024/15890 +- sec61b_hipsc_train/42/138024/16225 +- sec61b_hipsc_train/42/138024/16287 +- sec61b_hipsc_train/42/138024/16991 +- sec61b_hipsc_train/42/138025/15979 +- sec61b_hipsc_train/42/138025/16227 +- sec61b_hipsc_train/42/138025/16897 +- sec61b_hipsc_train/42/138025/17204 +- sec61b_hipsc_train/42/138025/17241 +- sec61b_hipsc_train/42/138026/15744 +- sec61b_hipsc_train/42/138026/16036 +- sec61b_hipsc_train/42/138026/16240 +- sec61b_hipsc_train/42/138026/17153 +- sec61b_hipsc_train/42/138026/17201 +- sec61b_hipsc_train/42/138026/17206 +- sec61b_hipsc_train/42/138026/17257 +- sec61b_hipsc_train/42/138027/17190 +- sec61b_hipsc_train/42/138027/17231 +- sec61b_hipsc_train/42/138027/17262 +- sec61b_hipsc_train/42/138028/15886 +- sec61b_hipsc_train/42/138028/16174 +- sec61b_hipsc_train/42/138028/16396 +- sec61b_hipsc_train/42/138028/17142 +- sec61b_hipsc_train/42/138028/17192 +- sec61b_hipsc_train/42/138028/17244 +- sec61b_hipsc_train/42/138030/15632 +- sec61b_hipsc_train/42/138030/15792 +- sec61b_hipsc_train/42/138030/15894 +- sec61b_hipsc_train/42/138032/15614 +- sec61b_hipsc_train/42/138032/15851 +- sec61b_hipsc_train/42/138032/16266 +- sec61b_hipsc_train/42/138032/16928 +- sec61b_hipsc_train/42/138032/17205 +- sec61b_hipsc_train/42/138032/17209 +- sec61b_hipsc_train/42/138033/17171 +- sec61b_hipsc_train/42/138033/17255 +- sec61b_hipsc_train/42/138037/15612 +- sec61b_hipsc_train/42/138037/16696 +- sec61b_hipsc_train/42/138037/17203 +- sec61b_hipsc_train/42/138037/17223 +- sec61b_hipsc_train/42/138044/15587 +- sec61b_hipsc_train/42/138044/16757 +- sec61b_hipsc_train/42/138044/17236 +- sec61b_hipsc_train/42/138045/15540 +- sec61b_hipsc_train/42/138045/15558 +- sec61b_hipsc_train/42/138045/15684 +- sec61b_hipsc_train/42/138045/15786 +- sec61b_hipsc_train/42/138045/16126 +- sec61b_hipsc_train/42/138045/16159 +- sec61b_hipsc_train/42/138045/16598 +- sec61b_hipsc_train/42/138045/17164 +- sec61b_hipsc_train/42/138045/17234 +- sec61b_hipsc_train/42/138045/17242 +- sec61b_hipsc_train/42/138045/17256 +- sec61b_hipsc_train/42/138247/17207 +- sec61b_hipsc_train/42/138249/16356 +- sec61b_hipsc_train/42/138249/17200 +- sec61b_hipsc_train/42/138251/15688 +- sec61b_hipsc_train/42/138251/15760 +- sec61b_hipsc_train/42/138251/15918 +- sec61b_hipsc_train/42/138251/16722 +- sec61b_hipsc_train/42/138251/16982 +- sec61b_hipsc_train/42/138251/17191 +- sec61b_hipsc_train/42/138253/15957 +- sec61b_hipsc_train/42/138253/16263 +- sec61b_hipsc_train/42/138253/16587 +- sec61b_hipsc_train/42/138253/16799 +- sec61b_hipsc_train/42/138253/16955 +- sec61b_hipsc_train/42/138257/16247 +- sec61b_hipsc_train/42/138257/16292 +- sec61b_hipsc_train/42/138257/16306 +- sec61b_hipsc_train/42/138257/16480 +- sec61b_hipsc_train/42/138257/17221 +- sec61b_hipsc_train/42/138261/15887 +- sec61b_hipsc_train/42/138261/16083 +- sec61b_hipsc_train/42/138261/16860 +- sec61b_a549_mantis_2024_11_07_train/B/1/001000 +- sec61b_a549_mantis_2024_11_07_train/B/1/001001 +- sec61b_a549_mantis_2024_11_07_train/B/3/001000 +- sec61b_a549_mantis_2024_11_07_train/B/3/001001 +- sec61b_a549_mantis_2025_07_24_train/A/1/002000 +- sec61b_a549_mantis_2025_07_24_train/A/1/002001 +- sec61b_a549_mantis_2025_08_26_train/A/1/001001 +- sec61b_a549_mantis_2025_08_26_train/A/1/001002 +- sec61b_a549_mantis_2025_08_26_train/A/1/002000 +- sec61b_a549_mantis_2025_08_26_train/A/1/002001 +- sec61b_a549_mantis_2025_08_26_train/A/1/002002 +test_fovs: +- sec61b_hipsc_test/4/38452/5187 +- sec61b_hipsc_test/4/38452/5201 +- sec61b_hipsc_test/4/38452/5203 +- sec61b_hipsc_test/4/38464/5173 +- sec61b_hipsc_test/4/38465/5189 +- sec61b_hipsc_test/4/38466/5200 +- sec61b_hipsc_test/4/39124/5286 +- sec61b_hipsc_test/4/39125/5224 +- sec61b_hipsc_test/4/39126/5289 +- sec61b_hipsc_test/4/39128/5230 +- sec61b_hipsc_test/4/39128/5254 +- sec61b_hipsc_test/4/39137/5252 +- sec61b_hipsc_test/4/39138/5268 +- sec61b_hipsc_test/4/39140/5293 +- sec61b_hipsc_test/4/39222/5281 +- sec61b_hipsc_test/4/39222/5311 +- sec61b_hipsc_test/4/39232/5329 +- sec61b_hipsc_test/4/39233/5304 +- sec61b_hipsc_test/4/39233/5313 +- sec61b_hipsc_test/4/39233/5327 +- sec61b_hipsc_test/4/39236/5305 +- sec61b_hipsc_test/4/40084/5357 +- sec61b_hipsc_test/4/40084/5415 +- sec61b_hipsc_test/4/40085/5421 +- sec61b_hipsc_test/4/40086/5362 +- sec61b_hipsc_test/4/40181/5434 +- sec61b_hipsc_test/4/40181/5451 +- sec61b_hipsc_test/4/40181/5453 +- sec61b_hipsc_test/4/40195/5479 +- sec61b_hipsc_test/4/40196/5471 +- sec61b_hipsc_test/4/40375/4612 +- sec61b_hipsc_test/4/40376/4568 +- sec61b_hipsc_test/4/40376/4601 +- sec61b_hipsc_test/4/40376/4604 +- sec61b_hipsc_test/4/40385/4565 +- sec61b_hipsc_test/4/40385/4572 +- sec61b_hipsc_test/4/40385/4576 +- sec61b_hipsc_test/4/40385/4610 +- sec61b_hipsc_test/4/40386/4603 +- sec61b_hipsc_test/4/40386/4606 +- sec61b_hipsc_test/4/40387/4570 +- sec61b_hipsc_test/4/40388/4591 +- sec61b_hipsc_test/4/40468/4624 +- sec61b_hipsc_test/4/40471/4659 +- sec61b_hipsc_test/4/40471/4661 +- sec61b_hipsc_test/4/40471/4679 +- sec61b_hipsc_test/4/40481/4627 +- sec61b_hipsc_test/4/40483/4621 +- sec61b_hipsc_test/4/40483/4637 +- sec61b_hipsc_test/4/40483/4644 +- sec61b_hipsc_test/4/40960/4630 +- sec61b_hipsc_test/4/40961/4665 +- sec61b_hipsc_test/4/40964/4643 +- sec61b_hipsc_test/4/41044/4869 +- sec61b_hipsc_test/4/41044/4891 +- sec61b_hipsc_test/4/41046/4849 +- sec61b_hipsc_test/4/41047/4885 +- sec61b_hipsc_test/4/41057/4887 +- sec61b_hipsc_test/4/41059/4886 +- sec61b_hipsc_test/4/41060/4901 +- sec61b_hipsc_test/4/41238/4828 +- sec61b_hipsc_test/4/41239/4823 +- sec61b_hipsc_test/4/41239/4832 +- sec61b_hipsc_test/4/41240/4818 +- sec61b_hipsc_test/4/41240/4834 +- sec61b_hipsc_test/4/41335/4803 +- sec61b_hipsc_test/4/41348/4809 +- sec61b_hipsc_test/4/41428/4713 +- sec61b_hipsc_test/4/41428/4718 +- sec61b_hipsc_test/4/41428/4743 +- sec61b_hipsc_test/4/41430/4744 +- sec61b_hipsc_test/4/41432/4729 +- sec61b_hipsc_test/4/41441/4725 +- sec61b_hipsc_test/4/41908/5037 +- sec61b_hipsc_test/4/41908/5061 +- sec61b_hipsc_test/4/41909/5071 +- sec61b_hipsc_test/4/41910/5031 +- sec61b_hipsc_test/4/41910/5058 +- sec61b_hipsc_test/4/41910/5088 +- sec61b_hipsc_test/4/41911/5027 +- sec61b_hipsc_test/4/42199/5048 +- sec61b_hipsc_test/4/42211/5034 +- sec61b_hipsc_test/42/136118/14223 +- sec61b_hipsc_test/42/136118/14225 +- sec61b_hipsc_test/42/136118/16503 +- sec61b_hipsc_test/42/136119/16504 +- sec61b_hipsc_test/42/136120/14221 +- sec61b_hipsc_test/42/136120/14224 +- sec61b_hipsc_test/42/136120/14228 +- sec61b_hipsc_test/42/136120/15747 +- sec61b_hipsc_test/42/136124/16127 +- sec61b_hipsc_test/42/138024/17222 +- sec61b_hipsc_test/42/138026/17232 +- sec61b_hipsc_test/42/138028/15839 +- sec61b_hipsc_test/42/138028/17202 +- sec61b_hipsc_test/42/138032/15577 +- sec61b_hipsc_test/42/138044/15777 +- sec61b_hipsc_test/42/138045/16692 +- sec61b_hipsc_test/42/138251/17249 +- sec61b_hipsc_test/42/138253/15966 +- sec61b_a549_mantis_2024_11_07_test/B/1/000000 +- sec61b_a549_mantis_2024_11_07_test/B/1/000001 +- sec61b_a549_mantis_2024_11_07_test/B/3/000000 +- sec61b_a549_mantis_2024_11_07_test/B/3/000001 +- sec61b_a549_mantis_2025_07_24_test/A/1/000000 +- sec61b_a549_mantis_2025_07_24_test/A/1/000001 +- sec61b_a549_mantis_2025_07_24_test/A/1/001000 +- sec61b_a549_mantis_2025_07_24_test/A/1/001001 +- sec61b_a549_mantis_2025_08_26_test/A/1/000000 +- sec61b_a549_mantis_2025_08_26_test/A/1/000001 +- sec61b_a549_mantis_2025_08_26_test/A/1/000002 +- sec61b_a549_mantis_2025_08_26_test/A/1/001000 diff --git a/applications/dynacell/configs/collections/virtual_staining/tomm20_joint_all_v1.yaml b/applications/dynacell/configs/collections/virtual_staining/tomm20_joint_all_v1.yaml new file mode 100644 index 000000000..b03669241 --- /dev/null +++ b/applications/dynacell/configs/collections/virtual_staining/tomm20_joint_all_v1.yaml @@ -0,0 +1,911 @@ +name: tomm20_joint_all_v1 +description: Joint frozen benchmark collection for target 'tomm20' across 6 source + datasets. Channels and FOV membership captured from the live train/test zarr stores + at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-24T19:29:30.139703+00:00' + created_by: Alex Kalinin +experiments: +- name: tomm20_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/TOMM20.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: tomm20_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/TOMM20.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_10_29_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_10_29_A549_TOMM20_ZIKV_DENV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_11_05_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_05_A549_TOMM20_ZIKV_DENV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_11_05_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_05_A549_TOMM20_ZIKV_DENV/test/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_11_21_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_21_A549_TOMM20_DENV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_11_21_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_21_A549_TOMM20_DENV/test/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2025_07_24_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2025_07_24_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV/test/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2025_08_26_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_08_26_A549_SEC61_TOMM20_ZIKV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2025_08_26_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_08_26_A549_SEC61_TOMM20_ZIKV/test/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +train_fovs: +- tomm20_hipsc_train/4/10614/1356 +- tomm20_hipsc_train/4/10624/1295 +- tomm20_hipsc_train/4/10624/1300 +- tomm20_hipsc_train/4/10624/1321 +- tomm20_hipsc_train/4/10625/1325 +- tomm20_hipsc_train/4/10625/1335 +- tomm20_hipsc_train/4/10900/1369 +- tomm20_hipsc_train/4/10900/1438 +- tomm20_hipsc_train/4/10901/1379 +- tomm20_hipsc_train/4/10901/1382 +- tomm20_hipsc_train/4/10903/1364 +- tomm20_hipsc_train/4/10903/1425 +- tomm20_hipsc_train/4/10904/1420 +- tomm20_hipsc_train/4/10904/1436 +- tomm20_hipsc_train/4/10915/1446 +- tomm20_hipsc_train/4/11380/1447 +- tomm20_hipsc_train/4/11396/1426 +- tomm20_hipsc_train/4/11396/1435 +- tomm20_hipsc_train/4/11396/1440 +- tomm20_hipsc_train/4/11478/1465 +- tomm20_hipsc_train/4/11488/1455 +- tomm20_hipsc_train/4/11489/1464 +- tomm20_hipsc_train/4/11489/1477 +- tomm20_hipsc_train/4/11490/1491 +- tomm20_hipsc_train/4/11492/1467 +- tomm20_hipsc_train/4/11572/1387 +- tomm20_hipsc_train/4/11572/1413 +- tomm20_hipsc_train/4/11573/1389 +- tomm20_hipsc_train/4/11574/1391 +- tomm20_hipsc_train/4/11575/1411 +- tomm20_hipsc_train/4/11575/1421 +- tomm20_hipsc_train/4/11669/1643 +- tomm20_hipsc_train/4/11670/1513 +- tomm20_hipsc_train/4/11672/1610 +- tomm20_hipsc_train/4/11681/1655 +- tomm20_hipsc_train/4/11682/1514 +- tomm20_hipsc_train/4/11682/1515 +- tomm20_hipsc_train/4/11682/1653 +- tomm20_hipsc_train/4/11683/1676 +- tomm20_hipsc_train/4/11684/1498 +- tomm20_hipsc_train/4/136707/16640 +- tomm20_hipsc_train/4/136707/16795 +- tomm20_hipsc_train/4/136708/16427 +- tomm20_hipsc_train/4/136710/15363 +- tomm20_hipsc_train/4/136710/15740 +- tomm20_hipsc_train/4/136710/16002 +- tomm20_hipsc_train/4/136710/16572 +- tomm20_hipsc_train/4/136712/15798 +- tomm20_hipsc_train/4/136712/17080 +- tomm20_hipsc_train/4/136712/17179 +- tomm20_hipsc_train/4/136714/15190 +- tomm20_hipsc_train/4/136717/16904 +- tomm20_hipsc_train/4/136719/15840 +- tomm20_hipsc_train/4/136719/16707 +- tomm20_hipsc_train/4/136721/15487 +- tomm20_hipsc_train/4/136721/15588 +- tomm20_hipsc_train/4/136721/15624 +- tomm20_hipsc_train/4/136721/16107 +- tomm20_hipsc_train/4/136723/16663 +- tomm20_hipsc_train/4/136723/16687 +- tomm20_hipsc_train/4/136723/16763 +- tomm20_hipsc_train/4/136725/16272 +- tomm20_hipsc_train/4/136736/15292 +- tomm20_hipsc_train/4/136736/16364 +- tomm20_hipsc_train/4/136738/14381 +- tomm20_hipsc_train/4/136738/16770 +- tomm20_hipsc_train/4/22132/2808 +- tomm20_hipsc_train/4/22132/2820 +- tomm20_hipsc_train/4/22133/2782 +- tomm20_hipsc_train/4/22133/2830 +- tomm20_hipsc_train/4/22134/2802 +- tomm20_hipsc_train/4/22135/2819 +- tomm20_hipsc_train/4/22135/2821 +- tomm20_hipsc_train/4/22325/3154 +- tomm20_hipsc_train/4/22326/3079 +- tomm20_hipsc_train/4/22326/3121 +- tomm20_hipsc_train/4/22326/3139 +- tomm20_hipsc_train/4/22327/3081 +- tomm20_hipsc_train/4/22327/3087 +- tomm20_hipsc_train/4/22327/3117 +- tomm20_hipsc_train/4/22327/3120 +- tomm20_hipsc_train/4/22327/3126 +- tomm20_hipsc_train/4/22327/3144 +- tomm20_hipsc_train/4/22327/3153 +- tomm20_hipsc_train/4/22328/3077 +- tomm20_hipsc_train/4/22328/3099 +- tomm20_hipsc_train/4/22328/3125 +- tomm20_hipsc_train/4/22328/3135 +- tomm20_hipsc_train/4/22339/3095 +- tomm20_hipsc_train/4/22339/3105 +- tomm20_hipsc_train/4/22339/3116 +- tomm20_hipsc_train/4/22339/3129 +- tomm20_hipsc_train/4/22339/3150 +- tomm20_hipsc_train/4/22340/3071 +- tomm20_hipsc_train/4/22612/2918 +- tomm20_hipsc_train/4/22612/2992 +- tomm20_hipsc_train/4/22613/2897 +- tomm20_hipsc_train/4/22614/2972 +- tomm20_hipsc_train/4/22615/2913 +- tomm20_hipsc_train/4/22615/2970 +- tomm20_hipsc_train/4/22624/2899 +- tomm20_hipsc_train/4/22624/2911 +- tomm20_hipsc_train/4/22624/2920 +- tomm20_hipsc_train/4/22625/2914 +- tomm20_hipsc_train/4/22709/3112 +- tomm20_hipsc_train/4/22711/3072 +- tomm20_hipsc_train/4/22720/3100 +- tomm20_hipsc_train/4/22720/3110 +- tomm20_hipsc_train/4/22721/3062 +- tomm20_hipsc_train/4/22721/3067 +- tomm20_hipsc_train/4/22900/3316 +- tomm20_hipsc_train/4/22901/3283 +- tomm20_hipsc_train/4/22901/3285 +- tomm20_hipsc_train/4/22902/3279 +- tomm20_hipsc_train/4/22915/3292 +- tomm20_hipsc_train/4/22916/3312 +- tomm20_hipsc_train/4/23284/3464 +- tomm20_hipsc_train/4/23284/3468 +- tomm20_hipsc_train/4/23284/3487 +- tomm20_hipsc_train/4/23284/3499 +- tomm20_hipsc_train/4/23285/3466 +- tomm20_hipsc_train/4/23285/3509 +- tomm20_hipsc_train/4/23286/3454 +- tomm20_hipsc_train/4/23286/3515 +- tomm20_hipsc_train/4/23287/3465 +- tomm20_hipsc_train/4/23287/3484 +- tomm20_hipsc_train/4/23383/3173 +- tomm20_hipsc_train/4/23383/3255 +- tomm20_hipsc_train/4/23384/3187 +- tomm20_hipsc_train/4/23384/3201 +- tomm20_hipsc_train/4/23392/3239 +- tomm20_hipsc_train/4/23393/3259 +- tomm20_hipsc_train/4/23394/3192 +- tomm20_hipsc_train/4/23394/3251 +- tomm20_hipsc_train/4/23476/3329 +- tomm20_hipsc_train/4/23478/3324 +- tomm20_hipsc_train/4/23478/3328 +- tomm20_hipsc_train/4/23478/3363 +- tomm20_hipsc_train/4/23479/3347 +- tomm20_hipsc_train/4/23572/3536 +- tomm20_hipsc_train/4/23573/3513 +- tomm20_hipsc_train/4/23573/3519 +- tomm20_hipsc_train/4/23573/3527 +- tomm20_hipsc_train/4/23573/3538 +- tomm20_hipsc_train/4/23574/3492 +- tomm20_hipsc_train/4/23574/3504 +- tomm20_hipsc_train/4/23585/3498 +- tomm20_hipsc_train/4/23764/3403 +- tomm20_hipsc_train/4/23766/3411 +- tomm20_hipsc_train/4/23767/3421 +- tomm20_hipsc_train/4/23767/3425 +- tomm20_hipsc_train/4/23778/3408 +- tomm20_hipsc_train/4/24148/3551 +- tomm20_hipsc_train/4/24148/3554 +- tomm20_hipsc_train/4/24148/3572 +- tomm20_hipsc_train/4/24149/3555 +- tomm20_hipsc_train/4/24149/3568 +- tomm20_hipsc_train/4/24150/3550 +- tomm20_hipsc_train/4/24150/3562 +- tomm20_hipsc_train/4/24151/3508 +- tomm20_hipsc_train/4/24151/3532 +- tomm20_hipsc_train/4/24151/3547 +- tomm20_hipsc_train/4/24151/3563 +- tomm20_hipsc_train/4/24152/3526 +- tomm20_hipsc_train/4/24152/3545 +- tomm20_hipsc_train/4/24152/3573 +- tomm20_hipsc_train/4/24160/3478 +- tomm20_hipsc_train/4/24160/3564 +- tomm20_hipsc_train/4/24724/3641 +- tomm20_hipsc_train/4/24724/3661 +- tomm20_hipsc_train/4/24724/3688 +- tomm20_hipsc_train/4/24727/3648 +- tomm20_hipsc_train/4/24727/3651 +- tomm20_hipsc_train/4/24727/3659 +- tomm20_hipsc_train/4/24727/3660 +- tomm20_hipsc_train/4/24728/3655 +- tomm20_hipsc_train/4/24728/3678 +- tomm20_hipsc_train/4/24739/3638 +- tomm20_hipsc_train/4/24739/3644 +- tomm20_hipsc_train/4/24739/3647 +- tomm20_hipsc_train/4/24739/3681 +- tomm20_hipsc_train/4/24739/3683 +- tomm20_hipsc_train/4/24739/3703 +- tomm20_hipsc_train/4/24740/3657 +- tomm20_hipsc_train/4/24740/3701 +- tomm20_hipsc_train/4/24820/14 +- tomm20_hipsc_train/4/24820/15 +- tomm20_hipsc_train/4/24820/18 +- tomm20_hipsc_train/4/24820/3 +- tomm20_hipsc_train/4/24821/11 +- tomm20_hipsc_train/4/24822/1 +- tomm20_hipsc_train/4/24833/2 +- tomm20_hipsc_train/4/24833/27 +- tomm20_hipsc_train/4/24834/23 +- tomm20_hipsc_train/4/24928/3614 +- tomm20_hipsc_train/4/24929/3580 +- tomm20_hipsc_train/4/24929/3600 +- tomm20_hipsc_train/4/24929/3603 +- tomm20_hipsc_train/4/24929/3608 +- tomm20_hipsc_train/4/24930/3583 +- tomm20_hipsc_train/4/24930/3617 +- tomm20_hipsc_train/4/24931/3581 +- tomm20_hipsc_train/4/24931/3606 +- tomm20_hipsc_train/4/24932/3598 +- tomm20_hipsc_train/4/25204/3792 +- tomm20_hipsc_train/4/25205/3812 +- tomm20_hipsc_train/4/25206/3806 +- tomm20_hipsc_train/4/25208/3798 +- tomm20_hipsc_train/4/25208/3815 +- tomm20_hipsc_train/4/25208/3821 +- tomm20_hipsc_train/4/25216/3794 +- tomm20_hipsc_train/4/25781/3833 +- tomm20_hipsc_train/4/25781/3843 +- tomm20_hipsc_train/4/25781/3854 +- tomm20_hipsc_train/4/25781/3858 +- tomm20_hipsc_train/4/25782/3855 +- tomm20_hipsc_train/4/25783/3849 +- tomm20_hipsc_train/4/25783/3857 +- tomm20_hipsc_train/4/25784/3852 +- tomm20_hipsc_train/4/27798/2892 +- tomm20_hipsc_train/4/27799/2871 +- tomm20_hipsc_train/4/27799/2884 +- tomm20_hipsc_train/4/27800/2875 +- tomm20_hipsc_train/4/27808/2862 +- tomm20_hipsc_train/4/27808/2876 +- tomm20_hipsc_train/4/27809/2886 +- tomm20_hipsc_train/4/27892/2930 +- tomm20_hipsc_train/4/27893/2938 +- tomm20_hipsc_train/4/27893/2950 +- tomm20_hipsc_train/4/27894/2945 +- tomm20_hipsc_train/4/27896/2943 +- tomm20_hipsc_train/4/27904/2979 +- tomm20_hipsc_train/4/27906/2983 +- tomm20_hipsc_train/4/27988/3025 +- tomm20_hipsc_train/4/27990/3026 +- tomm20_hipsc_train/4/27992/3014 +- tomm20_hipsc_train/4/28000/3038 +- tomm20_hipsc_train/4/28001/3005 +- tomm20_hipsc_train/4/28001/3027 +- tomm20_hipsc_train/4/28001/3031 +- tomm20_hipsc_train/4/28002/3007 +- tomm20_hipsc_train/4/28002/3022 +- tomm20_hipsc_train/4/28002/3036 +- tomm20_hipsc_train/4/28084/3232 +- tomm20_hipsc_train/4/28084/3254 +- tomm20_hipsc_train/4/28085/3213 +- tomm20_hipsc_train/4/28085/3258 +- tomm20_hipsc_train/4/28086/3211 +- tomm20_hipsc_train/4/28086/3236 +- tomm20_hipsc_train/4/28087/3240 +- tomm20_hipsc_train/4/28087/3242 +- tomm20_hipsc_train/4/28087/3266 +- tomm20_hipsc_train/4/28088/3205 +- tomm20_hipsc_train/4/28088/3238 +- tomm20_hipsc_train/4/28088/3268 +- tomm20_hipsc_train/4/28756/3366 +- tomm20_hipsc_train/4/28758/3397 +- tomm20_hipsc_train/4/28759/3399 +- tomm20_hipsc_train/4/28760/3388 +- tomm20_hipsc_train/4/28760/3402 +- tomm20_hipsc_train/4/28769/3372 +- tomm20_hipsc_train/4/28770/3377 +- tomm20_hipsc_train/4/29045/3774 +- tomm20_hipsc_train/4/29045/3779 +- tomm20_hipsc_train/4/29045/3782 +- tomm20_hipsc_train/4/29046/3750 +- tomm20_hipsc_train/4/29046/3762 +- tomm20_hipsc_train/4/29047/3766 +- tomm20_hipsc_train/4/29058/3772 +- tomm20_hipsc_train/4/29059/3758 +- tomm20_hipsc_train/4/29059/3765 +- tomm20_hipsc_train/4/29060/3753 +- tomm20_hipsc_train/4/29140/3684 +- tomm20_hipsc_train/4/29140/3716 +- tomm20_hipsc_train/4/29140/3726 +- tomm20_hipsc_train/4/29141/3709 +- tomm20_hipsc_train/4/29141/3719 +- tomm20_hipsc_train/4/29141/3728 +- tomm20_hipsc_train/4/29141/3742 +- tomm20_hipsc_train/4/29142/3695 +- tomm20_hipsc_train/4/29142/3739 +- tomm20_hipsc_train/4/29143/3680 +- tomm20_hipsc_train/4/29152/3708 +- tomm20_hipsc_train/4/29152/3712 +- tomm20_hipsc_train/4/29152/3723 +- tomm20_hipsc_train/4/29153/3725 +- tomm20_hipsc_train/4/29155/3689 +- tomm20_hipsc_train/4/29155/3714 +- tomm20_hipsc_train/4/29332/3865 +- tomm20_hipsc_train/4/29333/3868 +- tomm20_hipsc_train/4/29333/3908 +- tomm20_hipsc_train/4/29334/3889 +- tomm20_hipsc_train/4/29334/3890 +- tomm20_hipsc_train/4/29334/3892 +- tomm20_hipsc_train/4/29335/3867 +- tomm20_hipsc_train/4/29335/3879 +- tomm20_hipsc_train/4/29335/3900 +- tomm20_hipsc_train/4/30292/3893 +- tomm20_hipsc_train/4/30292/3913 +- tomm20_hipsc_train/4/30293/3905 +- tomm20_hipsc_train/4/30294/15038 +- tomm20_hipsc_train/4/30294/16432 +- tomm20_hipsc_train/4/30294/3906 +- tomm20_hipsc_train/4/30294/3912 +- tomm20_hipsc_train/4/30304/3866 +- tomm20_hipsc_train/4/30308/3869 +- tomm20_hipsc_train/4/30308/3871 +- tomm20_hipsc_train/4/30389/16772 +- tomm20_hipsc_train/4/30392/16282 +- tomm20_hipsc_train/4/30677/15449 +- tomm20_hipsc_train/4/30677/16684 +- tomm20_hipsc_train/4/30677/16969 +- tomm20_hipsc_train/4/30679/15295 +- tomm20_hipsc_train/4/30679/15878 +- tomm20_hipsc_train/4/30680/17051 +- tomm20_hipsc_train/4/30688/15165 +- tomm20_hipsc_train/4/30689/15310 +- tomm20_hipsc_train/4/5140/925 +- tomm20_hipsc_train/4/5140/933 +- tomm20_hipsc_train/4/5140/950 +- tomm20_hipsc_train/4/5141/928 +- tomm20_hipsc_train/4/5141/940 +- tomm20_hipsc_train/4/5143/954 +- tomm20_hipsc_train/4/5144/943 +- tomm20_hipsc_train/4/5236/869 +- tomm20_hipsc_train/4/5236/913 +- tomm20_hipsc_train/4/5237/858 +- tomm20_hipsc_train/4/5238/1043 +- tomm20_hipsc_train/4/5238/815 +- tomm20_hipsc_train/4/5238/867 +- tomm20_hipsc_train/4/5238/873 +- tomm20_hipsc_train/4/5238/938 +- tomm20_hipsc_train/4/5239/888 +- tomm20_hipsc_train/4/5248/1038 +- tomm20_hipsc_train/4/5248/910 +- tomm20_hipsc_train/4/5250/902 +- tomm20_hipsc_train/4/5910/824 +- tomm20_hipsc_train/4/5912/841 +- tomm20_hipsc_train/4/5920/843 +- tomm20_hipsc_train/4/5921/828 +- tomm20_hipsc_train/4/5923/837 +- tomm20_hipsc_train/4/5923/853 +- tomm20_hipsc_train/4/5923/855 +- tomm20_hipsc_train/4/5924/819 +- tomm20_hipsc_train/4/6485/1007 +- tomm20_hipsc_train/4/6485/1011 +- tomm20_hipsc_train/4/6485/978 +- tomm20_hipsc_train/4/6485/980 +- tomm20_hipsc_train/4/6485/997 +- tomm20_hipsc_train/4/6486/1002 +- tomm20_hipsc_train/4/6486/1006 +- tomm20_hipsc_train/4/6486/1012 +- tomm20_hipsc_train/4/6486/1022 +- tomm20_hipsc_train/4/6486/965 +- tomm20_hipsc_train/4/6486/968 +- tomm20_hipsc_train/4/6486/981 +- tomm20_hipsc_train/4/6487/1015 +- tomm20_hipsc_train/4/6487/1020 +- tomm20_hipsc_train/4/6487/993 +- tomm20_hipsc_train/4/6497/1014 +- tomm20_hipsc_train/4/6497/1017 +- tomm20_hipsc_train/4/6497/1025 +- tomm20_hipsc_train/4/6497/976 +- tomm20_hipsc_train/4/6774/1134 +- tomm20_hipsc_train/4/6774/1218 +- tomm20_hipsc_train/4/6775/1100 +- tomm20_hipsc_train/4/6775/1176 +- tomm20_hipsc_train/4/6775/1187 +- tomm20_hipsc_train/4/6775/1191 +- tomm20_hipsc_train/4/6775/1193 +- tomm20_hipsc_train/4/6775/1195 +- tomm20_hipsc_train/4/6775/1228 +- tomm20_hipsc_train/4/6775/1232 +- tomm20_hipsc_train/4/6775/1236 +- tomm20_hipsc_train/4/6775/1240 +- tomm20_hipsc_train/4/6775/1248 +- tomm20_hipsc_train/4/6776/1153 +- tomm20_hipsc_train/4/6776/1185 +- tomm20_hipsc_train/4/6776/1199 +- tomm20_hipsc_train/4/7156/1104 +- tomm20_hipsc_train/4/7157/1102 +- tomm20_hipsc_train/4/7158/1105 +- tomm20_hipsc_train/4/7158/1119 +- tomm20_hipsc_train/4/7158/1123 +- tomm20_hipsc_train/4/7348/1326 +- tomm20_hipsc_train/4/7349/1348 +- tomm20_hipsc_train/4/7349/1352 +- tomm20_hipsc_train/4/7636/1269 +- tomm20_hipsc_train/4/7636/1272 +- tomm20_hipsc_train/4/7636/1287 +- tomm20_hipsc_train/4/7637/1270 +- tomm20_hipsc_train/4/7637/1293 +- tomm20_hipsc_train/4/7638/1279 +- tomm20_hipsc_train/4/7650/1252 +- tomm20_hipsc_train/4/7650/1278 +- tomm20_hipsc_train/4/7650/1288 +- tomm20_hipsc_train/4/8214/897 +- tomm20_hipsc_train/4/8214/903 +- tomm20_hipsc_train/4/8214/907 +- tomm20_hipsc_train/4/8225/899 +- tomm20_hipsc_train/4/8225/904 +- tomm20_hipsc_train/4/8309/1032 +- tomm20_hipsc_train/4/8310/1091 +- tomm20_hipsc_train/4/8311/1074 +- tomm20_hipsc_train/4/8692/1096 +- tomm20_hipsc_train/4/8692/1114 +- tomm20_hipsc_train/4/8692/1227 +- tomm20_hipsc_train/4/8695/1082 +- tomm20_hipsc_train/4/8695/1198 +- tomm20_hipsc_train/4/8695/1211 +- tomm20_hipsc_train/4/8695/1215 +- tomm20_hipsc_train/4/8696/1079 +- tomm20_hipsc_train/4/8705/1221 +- tomm20_hipsc_train/4/8706/1072 +- tomm20_hipsc_train/4/8707/1219 +- tomm20_hipsc_train/4/8708/1127 +- tomm20_hipsc_train/4/8708/1173 +- tomm20_hipsc_train/4/8708/1213 +- tomm20_hipsc_train/4/8708/1233 +- tomm20_hipsc_train/4/8980/1167 +- tomm20_hipsc_train/4/8980/1168 +- tomm20_hipsc_train/4/8980/1175 +- tomm20_hipsc_train/4/8980/1181 +- tomm20_hipsc_train/4/8981/1143 +- tomm20_hipsc_train/4/8981/1155 +- tomm20_hipsc_train/4/8982/1150 +- tomm20_hipsc_train/4/8982/1163 +- tomm20_hipsc_train/4/9748/15080 +- tomm20_hipsc_train/4/9748/15365 +- tomm20_hipsc_train/4/9748/15563 +- tomm20_hipsc_train/4/9748/15711 +- tomm20_hipsc_train/4/9748/15871 +- tomm20_hipsc_train/4/9748/16327 +- tomm20_hipsc_train/4/9748/16440 +- tomm20_hipsc_train/4/9748/16524 +- tomm20_hipsc_train/4/9748/16929 +- tomm20_hipsc_train/4/9748/17154 +- tomm20_hipsc_train/42/135521/14270 +- tomm20_hipsc_train/42/135523/14265 +- tomm20_hipsc_train/42/135524/14251 +- tomm20_hipsc_train/42/135525/14254 +- tomm20_hipsc_train/42/135525/15339 +- tomm20_hipsc_train/42/135526/14250 +- tomm20_hipsc_train/42/135526/14256 +- tomm20_hipsc_train/42/135526/14257 +- tomm20_hipsc_train/42/135614/14199 +- tomm20_hipsc_train/42/135614/14210 +- tomm20_hipsc_train/42/135615/14176 +- tomm20_hipsc_train/42/135615/14194 +- tomm20_hipsc_train/42/135615/14209 +- tomm20_hipsc_train/42/135616/14159 +- tomm20_hipsc_train/42/135616/14160 +- tomm20_hipsc_train/42/135616/14180 +- tomm20_hipsc_train/42/135616/14191 +- tomm20_hipsc_train/42/135617/14162 +- tomm20_hipsc_train/42/135617/14200 +- tomm20_hipsc_train/42/135617/14213 +- tomm20_hipsc_train/42/135617/14218 +- tomm20_hipsc_train/42/135618/14161 +- tomm20_hipsc_train/42/135618/14170 +- tomm20_hipsc_train/42/135618/14177 +- tomm20_hipsc_train/42/135618/14203 +- tomm20_hipsc_train/42/135619/14174 +- tomm20_hipsc_train/42/135619/14208 +- tomm20_hipsc_train/42/135620/14192 +- tomm20_hipsc_train/42/135620/14202 +- tomm20_hipsc_train/42/135622/14167 +- tomm20_hipsc_train/42/135622/14181 +- tomm20_hipsc_train/42/135622/14197 +- tomm20_hipsc_train/42/135622/14217 +- tomm20_hipsc_train/42/136130/14294 +- tomm20_hipsc_train/42/136130/14297 +- tomm20_hipsc_train/42/136130/14305 +- tomm20_hipsc_train/42/136131/14307 +- tomm20_hipsc_train/42/136131/14315 +- tomm20_hipsc_train/42/136131/14319 +- tomm20_hipsc_train/42/136131/14335 +- tomm20_hipsc_train/42/136132/14322 +- tomm20_hipsc_train/42/136132/14326 +- tomm20_hipsc_train/42/136132/14332 +- tomm20_hipsc_train/42/136133/14283 +- tomm20_hipsc_train/42/136133/14285 +- tomm20_hipsc_train/42/136134/14291 +- tomm20_hipsc_train/42/136134/14328 +- tomm20_hipsc_train/42/136135/14316 +- tomm20_hipsc_train/42/136135/14321 +- tomm20_hipsc_train/42/136136/14279 +- tomm20_hipsc_train/42/137952/15541 +- tomm20_hipsc_train/42/137952/16945 +- tomm20_hipsc_train/42/137952/17148 +- tomm20_hipsc_train/42/137953/16951 +- tomm20_hipsc_train/42/137954/15782 +- tomm20_hipsc_train/42/137954/16856 +- tomm20_hipsc_train/42/137954/16893 +- tomm20_hipsc_train/42/137955/15694 +- tomm20_hipsc_train/42/137955/15892 +- tomm20_hipsc_train/42/137955/16043 +- tomm20_hipsc_train/42/137956/16613 +- tomm20_hipsc_train/42/137956/17196 +- tomm20_hipsc_train/42/137956/17233 +- tomm20_a549_mantis_2024_10_29_train/B/4/000000 +- tomm20_a549_mantis_2024_10_29_train/B/4/000001 +- tomm20_a549_mantis_2024_10_29_train/B/4/001000 +- tomm20_a549_mantis_2024_10_29_train/B/4/001001 +- tomm20_a549_mantis_2024_10_29_train/B/4/002001 +- tomm20_a549_mantis_2024_10_29_train/C/4/000000 +- tomm20_a549_mantis_2024_10_29_train/C/4/000001 +- tomm20_a549_mantis_2024_10_29_train/C/4/001000 +- tomm20_a549_mantis_2024_10_29_train/C/4/002000 +- tomm20_a549_mantis_2024_10_29_train/C/4/002001 +- tomm20_a549_mantis_2024_11_05_train/B/4/001001 +- tomm20_a549_mantis_2024_11_05_train/B/4/002000 +- tomm20_a549_mantis_2024_11_05_train/B/4/002001 +- tomm20_a549_mantis_2024_11_21_train/B/1/001001 +- tomm20_a549_mantis_2024_11_21_train/B/3/000000 +- tomm20_a549_mantis_2024_11_21_train/B/3/000001 +- tomm20_a549_mantis_2024_11_21_train/B/3/001000 +- tomm20_a549_mantis_2024_11_21_train/B/3/001001 +- tomm20_a549_mantis_2025_07_24_train/B/1/001001 +- tomm20_a549_mantis_2025_07_24_train/B/1/002000 +- tomm20_a549_mantis_2025_07_24_train/B/1/002001 +- tomm20_a549_mantis_2025_08_26_train/A/2/001000 +- tomm20_a549_mantis_2025_08_26_train/A/2/001001 +- tomm20_a549_mantis_2025_08_26_train/A/2/001002 +- tomm20_a549_mantis_2025_08_26_train/A/2/002000 +- tomm20_a549_mantis_2025_08_26_train/A/2/002001 +- tomm20_a549_mantis_2025_08_26_train/A/2/002002 +- tomm20_a549_mantis_2025_08_26_train/B/2/002000 +- tomm20_a549_mantis_2025_08_26_train/B/2/002001 +- tomm20_a549_mantis_2025_08_26_train/B/2/002002 +test_fovs: +- tomm20_hipsc_test/4/10612/1362 +- tomm20_hipsc_test/4/10624/1349 +- tomm20_hipsc_test/4/11380/1459 +- tomm20_hipsc_test/4/11380/1471 +- tomm20_hipsc_test/4/11384/1404 +- tomm20_hipsc_test/4/11476/16725 +- tomm20_hipsc_test/4/11477/1493 +- tomm20_hipsc_test/4/11492/1472 +- tomm20_hipsc_test/4/11575/1394 +- tomm20_hipsc_test/4/11670/1462 +- tomm20_hipsc_test/4/11680/1686 +- tomm20_hipsc_test/4/11682/1660 +- tomm20_hipsc_test/4/136707/16604 +- tomm20_hipsc_test/4/22132/2823 +- tomm20_hipsc_test/4/22133/2798 +- tomm20_hipsc_test/4/22135/2792 +- tomm20_hipsc_test/4/22135/2822 +- tomm20_hipsc_test/4/22325/3131 +- tomm20_hipsc_test/4/22326/3141 +- tomm20_hipsc_test/4/22327/3137 +- tomm20_hipsc_test/4/22340/3097 +- tomm20_hipsc_test/4/22612/2958 +- tomm20_hipsc_test/4/22612/2986 +- tomm20_hipsc_test/4/23285/3452 +- tomm20_hipsc_test/4/23286/3512 +- tomm20_hipsc_test/4/23381/3195 +- tomm20_hipsc_test/4/23382/3245 +- tomm20_hipsc_test/4/23384/3170 +- tomm20_hipsc_test/4/23384/3253 +- tomm20_hipsc_test/4/23394/3196 +- tomm20_hipsc_test/4/23572/3529 +- tomm20_hipsc_test/4/23768/3424 +- tomm20_hipsc_test/4/23777/3418 +- tomm20_hipsc_test/4/24149/3481 +- tomm20_hipsc_test/4/24150/3537 +- tomm20_hipsc_test/4/24724/3645 +- tomm20_hipsc_test/4/24724/3649 +- tomm20_hipsc_test/4/24834/13 +- tomm20_hipsc_test/4/24930/3599 +- tomm20_hipsc_test/4/24931/3592 +- tomm20_hipsc_test/4/24932/3588 +- tomm20_hipsc_test/4/25207/3818 +- tomm20_hipsc_test/4/25207/3824 +- tomm20_hipsc_test/4/27798/2891 +- tomm20_hipsc_test/4/27892/2961 +- tomm20_hipsc_test/4/27990/3010 +- tomm20_hipsc_test/4/27990/3012 +- tomm20_hipsc_test/4/27991/3009 +- tomm20_hipsc_test/4/27991/3028 +- tomm20_hipsc_test/4/28001/3016 +- tomm20_hipsc_test/4/28084/3200 +- tomm20_hipsc_test/4/28084/3214 +- tomm20_hipsc_test/4/28086/3250 +- tomm20_hipsc_test/4/28087/3224 +- tomm20_hipsc_test/4/28756/3370 +- tomm20_hipsc_test/4/28760/3390 +- tomm20_hipsc_test/4/29142/3718 +- tomm20_hipsc_test/4/29142/3720 +- tomm20_hipsc_test/4/29143/3679 +- tomm20_hipsc_test/4/29152/3740 +- tomm20_hipsc_test/4/29332/3860 +- tomm20_hipsc_test/4/29336/3885 +- tomm20_hipsc_test/4/29336/3896 +- tomm20_hipsc_test/4/30292/3909 +- tomm20_hipsc_test/4/30294/3901 +- tomm20_hipsc_test/4/30391/15032 +- tomm20_hipsc_test/4/30679/3933 +- tomm20_hipsc_test/4/5141/926 +- tomm20_hipsc_test/4/5143/953 +- tomm20_hipsc_test/4/5240/1073 +- tomm20_hipsc_test/4/5912/823 +- tomm20_hipsc_test/4/6485/990 +- tomm20_hipsc_test/4/6486/989 +- tomm20_hipsc_test/4/6486/991 +- tomm20_hipsc_test/4/6497/1009 +- tomm20_hipsc_test/4/6776/1122 +- tomm20_hipsc_test/4/7349/1359 +- tomm20_hipsc_test/4/7638/1280 +- tomm20_hipsc_test/4/7639/1264 +- tomm20_hipsc_test/4/7650/1285 +- tomm20_hipsc_test/4/8228/886 +- tomm20_hipsc_test/4/8228/893 +- tomm20_hipsc_test/4/8228/906 +- tomm20_hipsc_test/4/8692/1235 +- tomm20_hipsc_test/4/8705/1209 +- tomm20_hipsc_test/4/8705/1225 +- tomm20_hipsc_test/4/8982/1147 +- tomm20_hipsc_test/4/9748/16392 +- tomm20_hipsc_test/4/9748/16574 +- tomm20_hipsc_test/4/9748/16977 +- tomm20_hipsc_test/4/9749/16734 +- tomm20_hipsc_test/42/135525/16168 +- tomm20_hipsc_test/42/135615/14189 +- tomm20_hipsc_test/42/135621/14220 +- tomm20_hipsc_test/42/136130/14325 +- tomm20_hipsc_test/42/136133/14302 +- tomm20_hipsc_test/42/136134/14300 +- tomm20_hipsc_test/42/136136/14317 +- tomm20_hipsc_test/42/136136/14320 +- tomm20_hipsc_test/42/137953/15532 +- tomm20_a549_mantis_2024_11_05_test/B/4/000000 +- tomm20_a549_mantis_2024_11_05_test/B/4/000001 +- tomm20_a549_mantis_2024_11_05_test/B/4/001000 +- tomm20_a549_mantis_2024_11_05_test/C/4/001000 +- tomm20_a549_mantis_2024_11_05_test/C/4/001001 +- tomm20_a549_mantis_2024_11_05_test/C/4/002000 +- tomm20_a549_mantis_2024_11_05_test/C/4/002001 +- tomm20_a549_mantis_2024_11_21_test/B/1/000000 +- tomm20_a549_mantis_2024_11_21_test/B/1/000001 +- tomm20_a549_mantis_2024_11_21_test/B/1/001000 +- tomm20_a549_mantis_2024_11_21_test/B/2/000000 +- tomm20_a549_mantis_2024_11_21_test/B/2/000001 +- tomm20_a549_mantis_2024_11_21_test/B/2/001000 +- tomm20_a549_mantis_2024_11_21_test/B/2/001001 +- tomm20_a549_mantis_2024_11_21_test/C/2/000000 +- tomm20_a549_mantis_2024_11_21_test/C/2/000001 +- tomm20_a549_mantis_2024_11_21_test/C/2/001000 +- tomm20_a549_mantis_2024_11_21_test/C/2/001001 +- tomm20_a549_mantis_2025_07_24_test/B/1/000000 +- tomm20_a549_mantis_2025_07_24_test/B/1/000001 +- tomm20_a549_mantis_2025_07_24_test/B/1/001000 +- tomm20_a549_mantis_2025_07_24_test/B/2/000000 +- tomm20_a549_mantis_2025_07_24_test/B/2/000001 +- tomm20_a549_mantis_2025_07_24_test/B/2/001000 +- tomm20_a549_mantis_2025_07_24_test/B/2/001001 +- tomm20_a549_mantis_2025_07_24_test/B/2/002000 +- tomm20_a549_mantis_2025_07_24_test/B/2/002001 +- tomm20_a549_mantis_2025_08_26_test/A/2/000000 +- tomm20_a549_mantis_2025_08_26_test/A/2/000001 +- tomm20_a549_mantis_2025_08_26_test/A/2/000002 +- tomm20_a549_mantis_2025_08_26_test/B/2/000000 +- tomm20_a549_mantis_2025_08_26_test/B/2/000001 +- tomm20_a549_mantis_2025_08_26_test/B/2/000002 +- tomm20_a549_mantis_2025_08_26_test/B/2/001000 +- tomm20_a549_mantis_2025_08_26_test/B/2/001001 +- tomm20_a549_mantis_2025_08_26_test/B/2/001002 diff --git a/applications/dynacell/configs/collections/virtual_staining/tomm20_joint_mock_v1.yaml b/applications/dynacell/configs/collections/virtual_staining/tomm20_joint_mock_v1.yaml new file mode 100644 index 000000000..6af6bc8da --- /dev/null +++ b/applications/dynacell/configs/collections/virtual_staining/tomm20_joint_mock_v1.yaml @@ -0,0 +1,879 @@ +name: tomm20_joint_mock_v1 +description: Joint frozen benchmark collection for target 'tomm20' with condition + filter 'mock' across 6 source datasets. Channels and FOV membership captured from + the live train/test zarr stores at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-24T19:47:52.169999+00:00' + created_by: Alex Kalinin +experiments: +- name: tomm20_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/TOMM20.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: tomm20_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/TOMM20.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_10_29_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_10_29_A549_TOMM20_ZIKV_DENV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_11_05_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_05_A549_TOMM20_ZIKV_DENV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_11_05_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_05_A549_TOMM20_ZIKV_DENV/test/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_11_21_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_21_A549_TOMM20_DENV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_11_21_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_21_A549_TOMM20_DENV/test/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2025_07_24_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2025_07_24_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV/test/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2025_08_26_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_08_26_A549_SEC61_TOMM20_ZIKV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2025_08_26_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_08_26_A549_SEC61_TOMM20_ZIKV/test/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +train_fovs: +- tomm20_hipsc_train/4/10614/1356 +- tomm20_hipsc_train/4/10624/1295 +- tomm20_hipsc_train/4/10624/1300 +- tomm20_hipsc_train/4/10624/1321 +- tomm20_hipsc_train/4/10625/1325 +- tomm20_hipsc_train/4/10625/1335 +- tomm20_hipsc_train/4/10900/1369 +- tomm20_hipsc_train/4/10900/1438 +- tomm20_hipsc_train/4/10901/1379 +- tomm20_hipsc_train/4/10901/1382 +- tomm20_hipsc_train/4/10903/1364 +- tomm20_hipsc_train/4/10903/1425 +- tomm20_hipsc_train/4/10904/1420 +- tomm20_hipsc_train/4/10904/1436 +- tomm20_hipsc_train/4/10915/1446 +- tomm20_hipsc_train/4/11380/1447 +- tomm20_hipsc_train/4/11396/1426 +- tomm20_hipsc_train/4/11396/1435 +- tomm20_hipsc_train/4/11396/1440 +- tomm20_hipsc_train/4/11478/1465 +- tomm20_hipsc_train/4/11488/1455 +- tomm20_hipsc_train/4/11489/1464 +- tomm20_hipsc_train/4/11489/1477 +- tomm20_hipsc_train/4/11490/1491 +- tomm20_hipsc_train/4/11492/1467 +- tomm20_hipsc_train/4/11572/1387 +- tomm20_hipsc_train/4/11572/1413 +- tomm20_hipsc_train/4/11573/1389 +- tomm20_hipsc_train/4/11574/1391 +- tomm20_hipsc_train/4/11575/1411 +- tomm20_hipsc_train/4/11575/1421 +- tomm20_hipsc_train/4/11669/1643 +- tomm20_hipsc_train/4/11670/1513 +- tomm20_hipsc_train/4/11672/1610 +- tomm20_hipsc_train/4/11681/1655 +- tomm20_hipsc_train/4/11682/1514 +- tomm20_hipsc_train/4/11682/1515 +- tomm20_hipsc_train/4/11682/1653 +- tomm20_hipsc_train/4/11683/1676 +- tomm20_hipsc_train/4/11684/1498 +- tomm20_hipsc_train/4/136707/16640 +- tomm20_hipsc_train/4/136707/16795 +- tomm20_hipsc_train/4/136708/16427 +- tomm20_hipsc_train/4/136710/15363 +- tomm20_hipsc_train/4/136710/15740 +- tomm20_hipsc_train/4/136710/16002 +- tomm20_hipsc_train/4/136710/16572 +- tomm20_hipsc_train/4/136712/15798 +- tomm20_hipsc_train/4/136712/17080 +- tomm20_hipsc_train/4/136712/17179 +- tomm20_hipsc_train/4/136714/15190 +- tomm20_hipsc_train/4/136717/16904 +- tomm20_hipsc_train/4/136719/15840 +- tomm20_hipsc_train/4/136719/16707 +- tomm20_hipsc_train/4/136721/15487 +- tomm20_hipsc_train/4/136721/15588 +- tomm20_hipsc_train/4/136721/15624 +- tomm20_hipsc_train/4/136721/16107 +- tomm20_hipsc_train/4/136723/16663 +- tomm20_hipsc_train/4/136723/16687 +- tomm20_hipsc_train/4/136723/16763 +- tomm20_hipsc_train/4/136725/16272 +- tomm20_hipsc_train/4/136736/15292 +- tomm20_hipsc_train/4/136736/16364 +- tomm20_hipsc_train/4/136738/14381 +- tomm20_hipsc_train/4/136738/16770 +- tomm20_hipsc_train/4/22132/2808 +- tomm20_hipsc_train/4/22132/2820 +- tomm20_hipsc_train/4/22133/2782 +- tomm20_hipsc_train/4/22133/2830 +- tomm20_hipsc_train/4/22134/2802 +- tomm20_hipsc_train/4/22135/2819 +- tomm20_hipsc_train/4/22135/2821 +- tomm20_hipsc_train/4/22325/3154 +- tomm20_hipsc_train/4/22326/3079 +- tomm20_hipsc_train/4/22326/3121 +- tomm20_hipsc_train/4/22326/3139 +- tomm20_hipsc_train/4/22327/3081 +- tomm20_hipsc_train/4/22327/3087 +- tomm20_hipsc_train/4/22327/3117 +- tomm20_hipsc_train/4/22327/3120 +- tomm20_hipsc_train/4/22327/3126 +- tomm20_hipsc_train/4/22327/3144 +- tomm20_hipsc_train/4/22327/3153 +- tomm20_hipsc_train/4/22328/3077 +- tomm20_hipsc_train/4/22328/3099 +- tomm20_hipsc_train/4/22328/3125 +- tomm20_hipsc_train/4/22328/3135 +- tomm20_hipsc_train/4/22339/3095 +- tomm20_hipsc_train/4/22339/3105 +- tomm20_hipsc_train/4/22339/3116 +- tomm20_hipsc_train/4/22339/3129 +- tomm20_hipsc_train/4/22339/3150 +- tomm20_hipsc_train/4/22340/3071 +- tomm20_hipsc_train/4/22612/2918 +- tomm20_hipsc_train/4/22612/2992 +- tomm20_hipsc_train/4/22613/2897 +- tomm20_hipsc_train/4/22614/2972 +- tomm20_hipsc_train/4/22615/2913 +- tomm20_hipsc_train/4/22615/2970 +- tomm20_hipsc_train/4/22624/2899 +- tomm20_hipsc_train/4/22624/2911 +- tomm20_hipsc_train/4/22624/2920 +- tomm20_hipsc_train/4/22625/2914 +- tomm20_hipsc_train/4/22709/3112 +- tomm20_hipsc_train/4/22711/3072 +- tomm20_hipsc_train/4/22720/3100 +- tomm20_hipsc_train/4/22720/3110 +- tomm20_hipsc_train/4/22721/3062 +- tomm20_hipsc_train/4/22721/3067 +- tomm20_hipsc_train/4/22900/3316 +- tomm20_hipsc_train/4/22901/3283 +- tomm20_hipsc_train/4/22901/3285 +- tomm20_hipsc_train/4/22902/3279 +- tomm20_hipsc_train/4/22915/3292 +- tomm20_hipsc_train/4/22916/3312 +- tomm20_hipsc_train/4/23284/3464 +- tomm20_hipsc_train/4/23284/3468 +- tomm20_hipsc_train/4/23284/3487 +- tomm20_hipsc_train/4/23284/3499 +- tomm20_hipsc_train/4/23285/3466 +- tomm20_hipsc_train/4/23285/3509 +- tomm20_hipsc_train/4/23286/3454 +- tomm20_hipsc_train/4/23286/3515 +- tomm20_hipsc_train/4/23287/3465 +- tomm20_hipsc_train/4/23287/3484 +- tomm20_hipsc_train/4/23383/3173 +- tomm20_hipsc_train/4/23383/3255 +- tomm20_hipsc_train/4/23384/3187 +- tomm20_hipsc_train/4/23384/3201 +- tomm20_hipsc_train/4/23392/3239 +- tomm20_hipsc_train/4/23393/3259 +- tomm20_hipsc_train/4/23394/3192 +- tomm20_hipsc_train/4/23394/3251 +- tomm20_hipsc_train/4/23476/3329 +- tomm20_hipsc_train/4/23478/3324 +- tomm20_hipsc_train/4/23478/3328 +- tomm20_hipsc_train/4/23478/3363 +- tomm20_hipsc_train/4/23479/3347 +- tomm20_hipsc_train/4/23572/3536 +- tomm20_hipsc_train/4/23573/3513 +- tomm20_hipsc_train/4/23573/3519 +- tomm20_hipsc_train/4/23573/3527 +- tomm20_hipsc_train/4/23573/3538 +- tomm20_hipsc_train/4/23574/3492 +- tomm20_hipsc_train/4/23574/3504 +- tomm20_hipsc_train/4/23585/3498 +- tomm20_hipsc_train/4/23764/3403 +- tomm20_hipsc_train/4/23766/3411 +- tomm20_hipsc_train/4/23767/3421 +- tomm20_hipsc_train/4/23767/3425 +- tomm20_hipsc_train/4/23778/3408 +- tomm20_hipsc_train/4/24148/3551 +- tomm20_hipsc_train/4/24148/3554 +- tomm20_hipsc_train/4/24148/3572 +- tomm20_hipsc_train/4/24149/3555 +- tomm20_hipsc_train/4/24149/3568 +- tomm20_hipsc_train/4/24150/3550 +- tomm20_hipsc_train/4/24150/3562 +- tomm20_hipsc_train/4/24151/3508 +- tomm20_hipsc_train/4/24151/3532 +- tomm20_hipsc_train/4/24151/3547 +- tomm20_hipsc_train/4/24151/3563 +- tomm20_hipsc_train/4/24152/3526 +- tomm20_hipsc_train/4/24152/3545 +- tomm20_hipsc_train/4/24152/3573 +- tomm20_hipsc_train/4/24160/3478 +- tomm20_hipsc_train/4/24160/3564 +- tomm20_hipsc_train/4/24724/3641 +- tomm20_hipsc_train/4/24724/3661 +- tomm20_hipsc_train/4/24724/3688 +- tomm20_hipsc_train/4/24727/3648 +- tomm20_hipsc_train/4/24727/3651 +- tomm20_hipsc_train/4/24727/3659 +- tomm20_hipsc_train/4/24727/3660 +- tomm20_hipsc_train/4/24728/3655 +- tomm20_hipsc_train/4/24728/3678 +- tomm20_hipsc_train/4/24739/3638 +- tomm20_hipsc_train/4/24739/3644 +- tomm20_hipsc_train/4/24739/3647 +- tomm20_hipsc_train/4/24739/3681 +- tomm20_hipsc_train/4/24739/3683 +- tomm20_hipsc_train/4/24739/3703 +- tomm20_hipsc_train/4/24740/3657 +- tomm20_hipsc_train/4/24740/3701 +- tomm20_hipsc_train/4/24820/14 +- tomm20_hipsc_train/4/24820/15 +- tomm20_hipsc_train/4/24820/18 +- tomm20_hipsc_train/4/24820/3 +- tomm20_hipsc_train/4/24821/11 +- tomm20_hipsc_train/4/24822/1 +- tomm20_hipsc_train/4/24833/2 +- tomm20_hipsc_train/4/24833/27 +- tomm20_hipsc_train/4/24834/23 +- tomm20_hipsc_train/4/24928/3614 +- tomm20_hipsc_train/4/24929/3580 +- tomm20_hipsc_train/4/24929/3600 +- tomm20_hipsc_train/4/24929/3603 +- tomm20_hipsc_train/4/24929/3608 +- tomm20_hipsc_train/4/24930/3583 +- tomm20_hipsc_train/4/24930/3617 +- tomm20_hipsc_train/4/24931/3581 +- tomm20_hipsc_train/4/24931/3606 +- tomm20_hipsc_train/4/24932/3598 +- tomm20_hipsc_train/4/25204/3792 +- tomm20_hipsc_train/4/25205/3812 +- tomm20_hipsc_train/4/25206/3806 +- tomm20_hipsc_train/4/25208/3798 +- tomm20_hipsc_train/4/25208/3815 +- tomm20_hipsc_train/4/25208/3821 +- tomm20_hipsc_train/4/25216/3794 +- tomm20_hipsc_train/4/25781/3833 +- tomm20_hipsc_train/4/25781/3843 +- tomm20_hipsc_train/4/25781/3854 +- tomm20_hipsc_train/4/25781/3858 +- tomm20_hipsc_train/4/25782/3855 +- tomm20_hipsc_train/4/25783/3849 +- tomm20_hipsc_train/4/25783/3857 +- tomm20_hipsc_train/4/25784/3852 +- tomm20_hipsc_train/4/27798/2892 +- tomm20_hipsc_train/4/27799/2871 +- tomm20_hipsc_train/4/27799/2884 +- tomm20_hipsc_train/4/27800/2875 +- tomm20_hipsc_train/4/27808/2862 +- tomm20_hipsc_train/4/27808/2876 +- tomm20_hipsc_train/4/27809/2886 +- tomm20_hipsc_train/4/27892/2930 +- tomm20_hipsc_train/4/27893/2938 +- tomm20_hipsc_train/4/27893/2950 +- tomm20_hipsc_train/4/27894/2945 +- tomm20_hipsc_train/4/27896/2943 +- tomm20_hipsc_train/4/27904/2979 +- tomm20_hipsc_train/4/27906/2983 +- tomm20_hipsc_train/4/27988/3025 +- tomm20_hipsc_train/4/27990/3026 +- tomm20_hipsc_train/4/27992/3014 +- tomm20_hipsc_train/4/28000/3038 +- tomm20_hipsc_train/4/28001/3005 +- tomm20_hipsc_train/4/28001/3027 +- tomm20_hipsc_train/4/28001/3031 +- tomm20_hipsc_train/4/28002/3007 +- tomm20_hipsc_train/4/28002/3022 +- tomm20_hipsc_train/4/28002/3036 +- tomm20_hipsc_train/4/28084/3232 +- tomm20_hipsc_train/4/28084/3254 +- tomm20_hipsc_train/4/28085/3213 +- tomm20_hipsc_train/4/28085/3258 +- tomm20_hipsc_train/4/28086/3211 +- tomm20_hipsc_train/4/28086/3236 +- tomm20_hipsc_train/4/28087/3240 +- tomm20_hipsc_train/4/28087/3242 +- tomm20_hipsc_train/4/28087/3266 +- tomm20_hipsc_train/4/28088/3205 +- tomm20_hipsc_train/4/28088/3238 +- tomm20_hipsc_train/4/28088/3268 +- tomm20_hipsc_train/4/28756/3366 +- tomm20_hipsc_train/4/28758/3397 +- tomm20_hipsc_train/4/28759/3399 +- tomm20_hipsc_train/4/28760/3388 +- tomm20_hipsc_train/4/28760/3402 +- tomm20_hipsc_train/4/28769/3372 +- tomm20_hipsc_train/4/28770/3377 +- tomm20_hipsc_train/4/29045/3774 +- tomm20_hipsc_train/4/29045/3779 +- tomm20_hipsc_train/4/29045/3782 +- tomm20_hipsc_train/4/29046/3750 +- tomm20_hipsc_train/4/29046/3762 +- tomm20_hipsc_train/4/29047/3766 +- tomm20_hipsc_train/4/29058/3772 +- tomm20_hipsc_train/4/29059/3758 +- tomm20_hipsc_train/4/29059/3765 +- tomm20_hipsc_train/4/29060/3753 +- tomm20_hipsc_train/4/29140/3684 +- tomm20_hipsc_train/4/29140/3716 +- tomm20_hipsc_train/4/29140/3726 +- tomm20_hipsc_train/4/29141/3709 +- tomm20_hipsc_train/4/29141/3719 +- tomm20_hipsc_train/4/29141/3728 +- tomm20_hipsc_train/4/29141/3742 +- tomm20_hipsc_train/4/29142/3695 +- tomm20_hipsc_train/4/29142/3739 +- tomm20_hipsc_train/4/29143/3680 +- tomm20_hipsc_train/4/29152/3708 +- tomm20_hipsc_train/4/29152/3712 +- tomm20_hipsc_train/4/29152/3723 +- tomm20_hipsc_train/4/29153/3725 +- tomm20_hipsc_train/4/29155/3689 +- tomm20_hipsc_train/4/29155/3714 +- tomm20_hipsc_train/4/29332/3865 +- tomm20_hipsc_train/4/29333/3868 +- tomm20_hipsc_train/4/29333/3908 +- tomm20_hipsc_train/4/29334/3889 +- tomm20_hipsc_train/4/29334/3890 +- tomm20_hipsc_train/4/29334/3892 +- tomm20_hipsc_train/4/29335/3867 +- tomm20_hipsc_train/4/29335/3879 +- tomm20_hipsc_train/4/29335/3900 +- tomm20_hipsc_train/4/30292/3893 +- tomm20_hipsc_train/4/30292/3913 +- tomm20_hipsc_train/4/30293/3905 +- tomm20_hipsc_train/4/30294/15038 +- tomm20_hipsc_train/4/30294/16432 +- tomm20_hipsc_train/4/30294/3906 +- tomm20_hipsc_train/4/30294/3912 +- tomm20_hipsc_train/4/30304/3866 +- tomm20_hipsc_train/4/30308/3869 +- tomm20_hipsc_train/4/30308/3871 +- tomm20_hipsc_train/4/30389/16772 +- tomm20_hipsc_train/4/30392/16282 +- tomm20_hipsc_train/4/30677/15449 +- tomm20_hipsc_train/4/30677/16684 +- tomm20_hipsc_train/4/30677/16969 +- tomm20_hipsc_train/4/30679/15295 +- tomm20_hipsc_train/4/30679/15878 +- tomm20_hipsc_train/4/30680/17051 +- tomm20_hipsc_train/4/30688/15165 +- tomm20_hipsc_train/4/30689/15310 +- tomm20_hipsc_train/4/5140/925 +- tomm20_hipsc_train/4/5140/933 +- tomm20_hipsc_train/4/5140/950 +- tomm20_hipsc_train/4/5141/928 +- tomm20_hipsc_train/4/5141/940 +- tomm20_hipsc_train/4/5143/954 +- tomm20_hipsc_train/4/5144/943 +- tomm20_hipsc_train/4/5236/869 +- tomm20_hipsc_train/4/5236/913 +- tomm20_hipsc_train/4/5237/858 +- tomm20_hipsc_train/4/5238/1043 +- tomm20_hipsc_train/4/5238/815 +- tomm20_hipsc_train/4/5238/867 +- tomm20_hipsc_train/4/5238/873 +- tomm20_hipsc_train/4/5238/938 +- tomm20_hipsc_train/4/5239/888 +- tomm20_hipsc_train/4/5248/1038 +- tomm20_hipsc_train/4/5248/910 +- tomm20_hipsc_train/4/5250/902 +- tomm20_hipsc_train/4/5910/824 +- tomm20_hipsc_train/4/5912/841 +- tomm20_hipsc_train/4/5920/843 +- tomm20_hipsc_train/4/5921/828 +- tomm20_hipsc_train/4/5923/837 +- tomm20_hipsc_train/4/5923/853 +- tomm20_hipsc_train/4/5923/855 +- tomm20_hipsc_train/4/5924/819 +- tomm20_hipsc_train/4/6485/1007 +- tomm20_hipsc_train/4/6485/1011 +- tomm20_hipsc_train/4/6485/978 +- tomm20_hipsc_train/4/6485/980 +- tomm20_hipsc_train/4/6485/997 +- tomm20_hipsc_train/4/6486/1002 +- tomm20_hipsc_train/4/6486/1006 +- tomm20_hipsc_train/4/6486/1012 +- tomm20_hipsc_train/4/6486/1022 +- tomm20_hipsc_train/4/6486/965 +- tomm20_hipsc_train/4/6486/968 +- tomm20_hipsc_train/4/6486/981 +- tomm20_hipsc_train/4/6487/1015 +- tomm20_hipsc_train/4/6487/1020 +- tomm20_hipsc_train/4/6487/993 +- tomm20_hipsc_train/4/6497/1014 +- tomm20_hipsc_train/4/6497/1017 +- tomm20_hipsc_train/4/6497/1025 +- tomm20_hipsc_train/4/6497/976 +- tomm20_hipsc_train/4/6774/1134 +- tomm20_hipsc_train/4/6774/1218 +- tomm20_hipsc_train/4/6775/1100 +- tomm20_hipsc_train/4/6775/1176 +- tomm20_hipsc_train/4/6775/1187 +- tomm20_hipsc_train/4/6775/1191 +- tomm20_hipsc_train/4/6775/1193 +- tomm20_hipsc_train/4/6775/1195 +- tomm20_hipsc_train/4/6775/1228 +- tomm20_hipsc_train/4/6775/1232 +- tomm20_hipsc_train/4/6775/1236 +- tomm20_hipsc_train/4/6775/1240 +- tomm20_hipsc_train/4/6775/1248 +- tomm20_hipsc_train/4/6776/1153 +- tomm20_hipsc_train/4/6776/1185 +- tomm20_hipsc_train/4/6776/1199 +- tomm20_hipsc_train/4/7156/1104 +- tomm20_hipsc_train/4/7157/1102 +- tomm20_hipsc_train/4/7158/1105 +- tomm20_hipsc_train/4/7158/1119 +- tomm20_hipsc_train/4/7158/1123 +- tomm20_hipsc_train/4/7348/1326 +- tomm20_hipsc_train/4/7349/1348 +- tomm20_hipsc_train/4/7349/1352 +- tomm20_hipsc_train/4/7636/1269 +- tomm20_hipsc_train/4/7636/1272 +- tomm20_hipsc_train/4/7636/1287 +- tomm20_hipsc_train/4/7637/1270 +- tomm20_hipsc_train/4/7637/1293 +- tomm20_hipsc_train/4/7638/1279 +- tomm20_hipsc_train/4/7650/1252 +- tomm20_hipsc_train/4/7650/1278 +- tomm20_hipsc_train/4/7650/1288 +- tomm20_hipsc_train/4/8214/897 +- tomm20_hipsc_train/4/8214/903 +- tomm20_hipsc_train/4/8214/907 +- tomm20_hipsc_train/4/8225/899 +- tomm20_hipsc_train/4/8225/904 +- tomm20_hipsc_train/4/8309/1032 +- tomm20_hipsc_train/4/8310/1091 +- tomm20_hipsc_train/4/8311/1074 +- tomm20_hipsc_train/4/8692/1096 +- tomm20_hipsc_train/4/8692/1114 +- tomm20_hipsc_train/4/8692/1227 +- tomm20_hipsc_train/4/8695/1082 +- tomm20_hipsc_train/4/8695/1198 +- tomm20_hipsc_train/4/8695/1211 +- tomm20_hipsc_train/4/8695/1215 +- tomm20_hipsc_train/4/8696/1079 +- tomm20_hipsc_train/4/8705/1221 +- tomm20_hipsc_train/4/8706/1072 +- tomm20_hipsc_train/4/8707/1219 +- tomm20_hipsc_train/4/8708/1127 +- tomm20_hipsc_train/4/8708/1173 +- tomm20_hipsc_train/4/8708/1213 +- tomm20_hipsc_train/4/8708/1233 +- tomm20_hipsc_train/4/8980/1167 +- tomm20_hipsc_train/4/8980/1168 +- tomm20_hipsc_train/4/8980/1175 +- tomm20_hipsc_train/4/8980/1181 +- tomm20_hipsc_train/4/8981/1143 +- tomm20_hipsc_train/4/8981/1155 +- tomm20_hipsc_train/4/8982/1150 +- tomm20_hipsc_train/4/8982/1163 +- tomm20_hipsc_train/4/9748/15080 +- tomm20_hipsc_train/4/9748/15365 +- tomm20_hipsc_train/4/9748/15563 +- tomm20_hipsc_train/4/9748/15711 +- tomm20_hipsc_train/4/9748/15871 +- tomm20_hipsc_train/4/9748/16327 +- tomm20_hipsc_train/4/9748/16440 +- tomm20_hipsc_train/4/9748/16524 +- tomm20_hipsc_train/4/9748/16929 +- tomm20_hipsc_train/4/9748/17154 +- tomm20_hipsc_train/42/135521/14270 +- tomm20_hipsc_train/42/135523/14265 +- tomm20_hipsc_train/42/135524/14251 +- tomm20_hipsc_train/42/135525/14254 +- tomm20_hipsc_train/42/135525/15339 +- tomm20_hipsc_train/42/135526/14250 +- tomm20_hipsc_train/42/135526/14256 +- tomm20_hipsc_train/42/135526/14257 +- tomm20_hipsc_train/42/135614/14199 +- tomm20_hipsc_train/42/135614/14210 +- tomm20_hipsc_train/42/135615/14176 +- tomm20_hipsc_train/42/135615/14194 +- tomm20_hipsc_train/42/135615/14209 +- tomm20_hipsc_train/42/135616/14159 +- tomm20_hipsc_train/42/135616/14160 +- tomm20_hipsc_train/42/135616/14180 +- tomm20_hipsc_train/42/135616/14191 +- tomm20_hipsc_train/42/135617/14162 +- tomm20_hipsc_train/42/135617/14200 +- tomm20_hipsc_train/42/135617/14213 +- tomm20_hipsc_train/42/135617/14218 +- tomm20_hipsc_train/42/135618/14161 +- tomm20_hipsc_train/42/135618/14170 +- tomm20_hipsc_train/42/135618/14177 +- tomm20_hipsc_train/42/135618/14203 +- tomm20_hipsc_train/42/135619/14174 +- tomm20_hipsc_train/42/135619/14208 +- tomm20_hipsc_train/42/135620/14192 +- tomm20_hipsc_train/42/135620/14202 +- tomm20_hipsc_train/42/135622/14167 +- tomm20_hipsc_train/42/135622/14181 +- tomm20_hipsc_train/42/135622/14197 +- tomm20_hipsc_train/42/135622/14217 +- tomm20_hipsc_train/42/136130/14294 +- tomm20_hipsc_train/42/136130/14297 +- tomm20_hipsc_train/42/136130/14305 +- tomm20_hipsc_train/42/136131/14307 +- tomm20_hipsc_train/42/136131/14315 +- tomm20_hipsc_train/42/136131/14319 +- tomm20_hipsc_train/42/136131/14335 +- tomm20_hipsc_train/42/136132/14322 +- tomm20_hipsc_train/42/136132/14326 +- tomm20_hipsc_train/42/136132/14332 +- tomm20_hipsc_train/42/136133/14283 +- tomm20_hipsc_train/42/136133/14285 +- tomm20_hipsc_train/42/136134/14291 +- tomm20_hipsc_train/42/136134/14328 +- tomm20_hipsc_train/42/136135/14316 +- tomm20_hipsc_train/42/136135/14321 +- tomm20_hipsc_train/42/136136/14279 +- tomm20_hipsc_train/42/137952/15541 +- tomm20_hipsc_train/42/137952/16945 +- tomm20_hipsc_train/42/137952/17148 +- tomm20_hipsc_train/42/137953/16951 +- tomm20_hipsc_train/42/137954/15782 +- tomm20_hipsc_train/42/137954/16856 +- tomm20_hipsc_train/42/137954/16893 +- tomm20_hipsc_train/42/137955/15694 +- tomm20_hipsc_train/42/137955/15892 +- tomm20_hipsc_train/42/137955/16043 +- tomm20_hipsc_train/42/137956/16613 +- tomm20_hipsc_train/42/137956/17196 +- tomm20_hipsc_train/42/137956/17233 +- tomm20_a549_mantis_2024_10_29_train/B/4/000000 +- tomm20_a549_mantis_2024_10_29_train/B/4/000001 +- tomm20_a549_mantis_2024_10_29_train/B/4/001000 +- tomm20_a549_mantis_2024_10_29_train/B/4/001001 +- tomm20_a549_mantis_2024_10_29_train/B/4/002001 +- tomm20_a549_mantis_2024_11_05_train/B/4/001001 +- tomm20_a549_mantis_2024_11_05_train/B/4/002000 +- tomm20_a549_mantis_2024_11_05_train/B/4/002001 +- tomm20_a549_mantis_2024_11_21_train/B/1/001001 +- tomm20_a549_mantis_2024_11_21_train/B/3/000000 +- tomm20_a549_mantis_2024_11_21_train/B/3/000001 +- tomm20_a549_mantis_2024_11_21_train/B/3/001000 +- tomm20_a549_mantis_2024_11_21_train/B/3/001001 +- tomm20_a549_mantis_2025_07_24_train/B/1/001001 +- tomm20_a549_mantis_2025_07_24_train/B/1/002000 +- tomm20_a549_mantis_2025_07_24_train/B/1/002001 +- tomm20_a549_mantis_2025_08_26_train/A/2/001000 +- tomm20_a549_mantis_2025_08_26_train/A/2/001001 +- tomm20_a549_mantis_2025_08_26_train/A/2/001002 +- tomm20_a549_mantis_2025_08_26_train/A/2/002000 +- tomm20_a549_mantis_2025_08_26_train/A/2/002001 +- tomm20_a549_mantis_2025_08_26_train/A/2/002002 +test_fovs: +- tomm20_hipsc_test/4/10612/1362 +- tomm20_hipsc_test/4/10624/1349 +- tomm20_hipsc_test/4/11380/1459 +- tomm20_hipsc_test/4/11380/1471 +- tomm20_hipsc_test/4/11384/1404 +- tomm20_hipsc_test/4/11476/16725 +- tomm20_hipsc_test/4/11477/1493 +- tomm20_hipsc_test/4/11492/1472 +- tomm20_hipsc_test/4/11575/1394 +- tomm20_hipsc_test/4/11670/1462 +- tomm20_hipsc_test/4/11680/1686 +- tomm20_hipsc_test/4/11682/1660 +- tomm20_hipsc_test/4/136707/16604 +- tomm20_hipsc_test/4/22132/2823 +- tomm20_hipsc_test/4/22133/2798 +- tomm20_hipsc_test/4/22135/2792 +- tomm20_hipsc_test/4/22135/2822 +- tomm20_hipsc_test/4/22325/3131 +- tomm20_hipsc_test/4/22326/3141 +- tomm20_hipsc_test/4/22327/3137 +- tomm20_hipsc_test/4/22340/3097 +- tomm20_hipsc_test/4/22612/2958 +- tomm20_hipsc_test/4/22612/2986 +- tomm20_hipsc_test/4/23285/3452 +- tomm20_hipsc_test/4/23286/3512 +- tomm20_hipsc_test/4/23381/3195 +- tomm20_hipsc_test/4/23382/3245 +- tomm20_hipsc_test/4/23384/3170 +- tomm20_hipsc_test/4/23384/3253 +- tomm20_hipsc_test/4/23394/3196 +- tomm20_hipsc_test/4/23572/3529 +- tomm20_hipsc_test/4/23768/3424 +- tomm20_hipsc_test/4/23777/3418 +- tomm20_hipsc_test/4/24149/3481 +- tomm20_hipsc_test/4/24150/3537 +- tomm20_hipsc_test/4/24724/3645 +- tomm20_hipsc_test/4/24724/3649 +- tomm20_hipsc_test/4/24834/13 +- tomm20_hipsc_test/4/24930/3599 +- tomm20_hipsc_test/4/24931/3592 +- tomm20_hipsc_test/4/24932/3588 +- tomm20_hipsc_test/4/25207/3818 +- tomm20_hipsc_test/4/25207/3824 +- tomm20_hipsc_test/4/27798/2891 +- tomm20_hipsc_test/4/27892/2961 +- tomm20_hipsc_test/4/27990/3010 +- tomm20_hipsc_test/4/27990/3012 +- tomm20_hipsc_test/4/27991/3009 +- tomm20_hipsc_test/4/27991/3028 +- tomm20_hipsc_test/4/28001/3016 +- tomm20_hipsc_test/4/28084/3200 +- tomm20_hipsc_test/4/28084/3214 +- tomm20_hipsc_test/4/28086/3250 +- tomm20_hipsc_test/4/28087/3224 +- tomm20_hipsc_test/4/28756/3370 +- tomm20_hipsc_test/4/28760/3390 +- tomm20_hipsc_test/4/29142/3718 +- tomm20_hipsc_test/4/29142/3720 +- tomm20_hipsc_test/4/29143/3679 +- tomm20_hipsc_test/4/29152/3740 +- tomm20_hipsc_test/4/29332/3860 +- tomm20_hipsc_test/4/29336/3885 +- tomm20_hipsc_test/4/29336/3896 +- tomm20_hipsc_test/4/30292/3909 +- tomm20_hipsc_test/4/30294/3901 +- tomm20_hipsc_test/4/30391/15032 +- tomm20_hipsc_test/4/30679/3933 +- tomm20_hipsc_test/4/5141/926 +- tomm20_hipsc_test/4/5143/953 +- tomm20_hipsc_test/4/5240/1073 +- tomm20_hipsc_test/4/5912/823 +- tomm20_hipsc_test/4/6485/990 +- tomm20_hipsc_test/4/6486/989 +- tomm20_hipsc_test/4/6486/991 +- tomm20_hipsc_test/4/6497/1009 +- tomm20_hipsc_test/4/6776/1122 +- tomm20_hipsc_test/4/7349/1359 +- tomm20_hipsc_test/4/7638/1280 +- tomm20_hipsc_test/4/7639/1264 +- tomm20_hipsc_test/4/7650/1285 +- tomm20_hipsc_test/4/8228/886 +- tomm20_hipsc_test/4/8228/893 +- tomm20_hipsc_test/4/8228/906 +- tomm20_hipsc_test/4/8692/1235 +- tomm20_hipsc_test/4/8705/1209 +- tomm20_hipsc_test/4/8705/1225 +- tomm20_hipsc_test/4/8982/1147 +- tomm20_hipsc_test/4/9748/16392 +- tomm20_hipsc_test/4/9748/16574 +- tomm20_hipsc_test/4/9748/16977 +- tomm20_hipsc_test/4/9749/16734 +- tomm20_hipsc_test/42/135525/16168 +- tomm20_hipsc_test/42/135615/14189 +- tomm20_hipsc_test/42/135621/14220 +- tomm20_hipsc_test/42/136130/14325 +- tomm20_hipsc_test/42/136133/14302 +- tomm20_hipsc_test/42/136134/14300 +- tomm20_hipsc_test/42/136136/14317 +- tomm20_hipsc_test/42/136136/14320 +- tomm20_hipsc_test/42/137953/15532 +- tomm20_a549_mantis_2024_11_05_test/B/4/000000 +- tomm20_a549_mantis_2024_11_05_test/B/4/000001 +- tomm20_a549_mantis_2024_11_05_test/B/4/001000 +- tomm20_a549_mantis_2024_11_21_test/B/1/000000 +- tomm20_a549_mantis_2024_11_21_test/B/1/000001 +- tomm20_a549_mantis_2024_11_21_test/B/1/001000 +- tomm20_a549_mantis_2025_07_24_test/B/1/000000 +- tomm20_a549_mantis_2025_07_24_test/B/1/000001 +- tomm20_a549_mantis_2025_07_24_test/B/1/001000 +- tomm20_a549_mantis_2025_08_26_test/A/2/000000 +- tomm20_a549_mantis_2025_08_26_test/A/2/000001 +- tomm20_a549_mantis_2025_08_26_test/A/2/000002 diff --git a/applications/dynacell/configs/recipes/models/celldiff_fm_2d.yml b/applications/dynacell/configs/recipes/models/celldiff_fm_2d.yml new file mode 100644 index 000000000..5f3b86382 --- /dev/null +++ b/applications/dynacell/configs/recipes/models/celldiff_fm_2d.yml @@ -0,0 +1,32 @@ +# Model recipe: CellDiff-2D — the CELLDiffNet flow-matching backbone run +# Z-preserving at Z=1 for the in-focus 2D benchmark track. +# +# Mirrors recipes/models/celldiff_fm.yml but: +# - input_spatial_size: [8, 512, 512] -> [1, 512, 512] +# - patch_size: 4 -> [1, 4, 4] +# The encoder already strides (1, 2, 2) (Z-preserving, celldiff_net.py), so +# only the ViT bottleneck needed changing: its PatchEmbed3D was a *cubic* +# Conv3d(kernel=patch, stride=patch), which cannot consume a size-1 Z axis. +# patch_size now accepts per-axis (D, H, W) extents; a cubic patch at D=1 +# still raises rather than silently reshaping (see celldiff_2d_test.py). +# +# The architecture is unchanged otherwise — CellDiff-2D is CELLDiffNet with +# the Z axis frozen, not a distinct network. Dropping the Z patch axis costs +# ~12.7M of the 3D model's 93.4M parameters (the patch-embed and final-layer +# projections shrink by 4x); everything else is identical. +model: + class_path: dynacell.engine.DynacellFlowMatching + init_args: + net_config: + input_spatial_size: [1, 512, 512] + in_channels: 1 + dims: [64, 128, 256, 256] + num_res_block: [2, 2, 2] + hidden_size: 512 + num_heads: 8 + dim_head: 64 + num_hidden_layers: 8 + patch_size: [1, 4, 4] + transport_config: + path_type: Linear + prediction: velocity diff --git a/applications/dynacell/configs/recipes/models/fnet2d.yml b/applications/dynacell/configs/recipes/models/fnet2d.yml new file mode 100644 index 000000000..1b549550c --- /dev/null +++ b/applications/dynacell/configs/recipes/models/fnet2d.yml @@ -0,0 +1,23 @@ +# Model recipe: FNet2D — FNet3D recursive encoder-decoder (Ounkomol et al. +# 2018) run Z-preserving at Z=1 for the in-focus 2D benchmark track. +# +# Mirrors recipes/models/fnet3d.yml but: +# - in_stack_depth: 1 (single in-focus plane, not the 32-plane stack) +# - downsample_z: false (Z-preserving encoder: stride (1,2,2) + +# ConvTranspose3d k=(1,3,3)). Required so the base UNet3DBase skips the +# `D % 2**depth` divisor check and can run at Z=1 (see +# viscy_models/unet/unet3d.py downsample_z, unet3d_base.py:162-168). +# architecture stays "FNet3D" — the dynacell registry maps it to the +# viscy_models.Unet3d subclass (engine.py:45); FNet2D is that same net +# with the Z axis frozen, not a distinct architecture. +model: + class_path: dynacell.engine.DynacellUNet + init_args: + architecture: FNet3D + model_config: + in_channels: 1 + out_channels: 1 + depth: 4 + mult_chan: 32 + in_stack_depth: 1 + downsample_z: false diff --git a/applications/dynacell/configs/recipes/models/pix2pix2d_unetvit.yml b/applications/dynacell/configs/recipes/models/pix2pix2d_unetvit.yml new file mode 100644 index 000000000..cda94322d --- /dev/null +++ b/applications/dynacell/configs/recipes/models/pix2pix2d_unetvit.yml @@ -0,0 +1,54 @@ +# Model recipe: pix2pix2d_unetvit — the UNetViT generator + multi-scale +# PatchGAN discriminator run Z-preserving at Z=1 for the in-focus 2D +# benchmark track. +# +# Mirrors recipes/models/pix2pix3d_unetvit.yml but: +# - generator input_spatial_size: [8, 512, 512] -> [1, 512, 512] +# - generator patch_size: 4 -> [1, 4, 4] +# - discriminator preserve_z: (absent) -> true +# +# The generator needed NO new code. UNetViT3D already builds with +# downsample_z=False (encoder strides (1, 2, 2)) and its ViTBottleneck3D +# already takes per-axis patch extents, because the CellDiff-2D track added +# that in 0126fe6f and both models share the bottleneck. Measured: the 3D +# config is 78.1M params and round-trips [8, 512, 512]; this one is 65.3M and +# round-trips [1, 512, 512]. A cubic patch_size=4 at D=1 raises a clear +# divisibility error rather than silently reshaping. +# +# The DISCRIMINATOR is what blocked Z=1, and it is a real edit: PatchGAN3D +# layers 1-4 used a *cubic* kernel_size=4 with padding=1, so a size-1 Z axis +# pads to 3 against a size-4 kernel and torch raises "Kernel size can't be +# greater than actual input size". Only layer 5 had been written Z-safe as +# (1, 4, 4)/(0, 1, 1). preserve_z=True collapses the kernel and padding on Z +# for layers 1-4 and drops the Z stride of layers 3-4, so Z passes through +# untouched instead of merely being tolerated. preserve_z=False reproduces the +# published 3D topology bit-for-bit, pinned by +# test_patchgan3d_preserve_z_leaves_the_3d_topology_untouched. +# +# The inter-scale pooling was already YX-only (avg_pool3d kernel (1, 2, 2)), +# so the multi-scale wrapper needed nothing beyond forwarding the flag. +# +# lambda_l1 = 100.0 is held at the 3D value; every training-recipe knob +# (loss_type, lr, R1, EMA) lives in the fit overlay, as it does for 3D. +model: + class_path: dynacell.engine.DynacellGAN + init_args: + architecture: UNetViT3D + generator_config: + input_spatial_size: [1, 512, 512] + in_channels: 1 + out_channels: 1 + dims: [64, 128, 256, 256] + num_res_block: [2, 2, 2] + hidden_size: 512 + num_heads: 8 + dim_head: 64 + num_hidden_layers: 8 + patch_size: [1, 4, 4] + discriminator_config: + in_channels: 2 + base_channels: 64 + num_scales: 2 # multi-scale D (pix2pixHD-style); set 1 to ablate + use_spectral_norm: true + preserve_z: true # required at Z=1; see the header + lambda_l1: 100.0 diff --git a/applications/dynacell/configs/recipes/modes/spotlight.yml b/applications/dynacell/configs/recipes/modes/spotlight.yml index 5d686b260..70d809a8f 100644 --- a/applications/dynacell/configs/recipes/modes/spotlight.yml +++ b/applications/dynacell/configs/recipes/modes/spotlight.yml @@ -6,6 +6,10 @@ model: init_args: lambda_mse: 0.5 sigmoid_k: -0.95 + # INERT while data.fg_mask_key is set below: forward() short-circuits + # on `if fg_mask is not None`, so the mask from the store defines + # foreground and this threshold is never consulted. It applies only if + # fg_mask_key is removed. Same for data.nonzero_threshold. fg_threshold: 0.0 data: init_args: diff --git a/applications/dynacell/configs/recipes/topology/ddp_4gpu_gan.yml b/applications/dynacell/configs/recipes/topology/ddp_4gpu_gan.yml index 513f415b5..000feab15 100644 --- a/applications/dynacell/configs/recipes/topology/ddp_4gpu_gan.yml +++ b/applications/dynacell/configs/recipes/topology/ddp_4gpu_gan.yml @@ -20,6 +20,16 @@ # the unused-param scan and is strictly faster for fully-active graphs. trainer: accelerator: gpu - strategy: ddp_find_unused_parameters_true + # Explicit DDPStrategy(find_unused_parameters=True) + a 3 h process-group + # timeout (default 30 min): on a contended shared FS, epoch-boundary + # checkpoint writes across many concurrent DDP jobs can stall one rank past + # 30 min, tripping the NCCL watchdog on the epoch-end metric ALLREDUCE and + # aborting the run. A longer timeout tolerates transient I/O stalls (same fix + # as model_overlays/fcmae_vscyto3d_fit.yml). + strategy: + class_path: lightning.pytorch.strategies.DDPStrategy + init_args: + find_unused_parameters: true + timeout: "3:00:00" # h:m:s (jsonargparse parses timedelta from this string form) devices: 4 num_nodes: 1 diff --git a/applications/dynacell/configs/recipes/trainer/predict.yml b/applications/dynacell/configs/recipes/trainer/predict.yml index d6a6bd349..d3d85fc9a 100644 --- a/applications/dynacell/configs/recipes/trainer/predict.yml +++ b/applications/dynacell/configs/recipes/trainer/predict.yml @@ -3,6 +3,7 @@ # single-GPU here. trainer: precision: 32-true + logger: false callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: From cdbfcfc6dc9d6330fa15a00a04588c0dfe84c4bd Mon Sep 17 00:00:00 2001 From: Alexandr Kalinin Date: Mon, 26 Oct 2026 16:02:24 -0700 Subject: [PATCH 26/72] feat(dynacell): DynaCell v1.1 application code from dynacell-models Port every DynaCell code path of dynacell-models verbatim (226 non-merge commits since 2026-06-16; PRs #479-#530): the evaluation pipeline (cpdino/MorphEm/focus-aware 2D, focus2d slab metrics, foreground-limited metrics, MicroMS3IM, scale-invariant pixel metrics, CP shared space, provenance and cache invalidation), the paths registry, preprocessing/registry/croissant/distribution, the launcher and stall watchdog, the lite benchmark and CELL-Diff fast inference, the 2D track, the HF demo, docs, and the engine, celldiff_wrapper and mask_conditioning modules exactly as on dynacell-models. The three LightningModules keep their Spotlight training hooks (seg_aux, seg_consistency, mask_mode, target_bg_lowpass). Every hook defaults off, the bit-identity tests guard that, and only Spotlight leaves turn them on; two DynaCell-paper 2D checkpoints store seg_aux_weight in their hparams, so a hook-free engine could not resume them. mask_conditioning.py comes along because engine.py and celldiff_wrapper.py import it. The files that import the Spotlight leaf generator are trimmed in the commits that follow. Co-Authored-By: Claude Opus 5.5 --- applications/dynacell/.gitignore | 3 + applications/dynacell/CITATION.cff | 117 ++ applications/dynacell/CLAUDE.md | 266 ++- applications/dynacell/README.md | 109 +- .../docs/evaluating-external-checkpoints.md | 496 ++++++ applications/dynacell/examples/README.md | 20 + .../dynacell/examples/hf_demo/AGENT.md | 9 +- .../examples/hf_demo/build_demo_data.py | 95 + .../examples/hf_demo/build_demo_data_test.py | 96 + .../hf_demo/cards/checkpoints_README.md | 26 +- .../hf_demo/cards/demo_data_README.md | 40 +- .../examples/hf_demo/hf_space/README.md | 34 +- .../dynacell/examples/hf_demo/hf_space/app.py | 105 +- .../hf_space/config_templates/celldiff.yaml | 3 +- .../hf_space/config_templates/fnet3d.yaml | 5 +- .../hf_space/config_templates/vscyto3d.yaml | 1 + .../hf_demo/hf_space/predict_runner.py | 16 +- .../hf_demo/hf_space/requirements.txt | 12 +- .../examples/hf_demo/upload_checkpoints.py | 96 +- .../examples/hf_demo/upload_demo_data.py | 51 + .../examples/hf_demo/upload_hf_space.py | 2 + .../get-to-know-dynacell-dataset.ipynb | 128 +- applications/dynacell/pyproject.toml | 38 +- applications/dynacell/src/README.md | 14 + applications/dynacell/src/dynacell/README.md | 43 + .../dynacell/src/dynacell/__main__.py | 28 + .../dynacell/src/dynacell/_compose_hook.py | 11 + .../virtual_staining/membrane_ipsc_v1.yaml | 658 +++++++ .../membrane_joint_all_v1.yaml | 941 ++++++++++ .../membrane_joint_mock_v1.yaml | 779 +++++++++ .../virtual_staining/nucleus_ipsc_v1.yaml | 658 +++++++ .../nucleus_joint_all_v1.yaml | 941 ++++++++++ .../nucleus_joint_mock_v1.yaml | 779 +++++++++ .../virtual_staining/sec61b_ipsc_v1.yaml | 587 +++++++ .../virtual_staining/sec61b_joint_all_v1.yaml | 806 +++++++++ .../sec61b_joint_mock_v1.yaml | 731 ++++++++ .../virtual_staining/tomm20_joint_all_v1.yaml | 911 ++++++++++ .../tomm20_joint_mock_v1.yaml | 879 ++++++++++ .../2024_10_29_A549_TOMM20_ZIKV_DENV.yaml | 47 + .../2024_10_31_A549_SEC61_ZIKV_DENV.yaml | 45 + .../2024_11_05_A549_TOMM20_ZIKV_DENV.yaml | 47 + .../platemaps/2024_11_07_A549_SEC61_DENV.yaml | 36 + .../2024_11_21_A549_TOMM20_DENV.yaml | 37 + ...25_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV.yaml | 41 + .../2025_08_26_A549_SEC61_TOMM20_ZIKV.yaml | 39 + .../2026_03_26_A549_CAAX_H2B_DENV_ZIKV.yaml | 45 + .../2024_10_29_A549_TOMM20_ZIKV_DENV.yaml | 26 + .../2024_10_31_A549_SEC61_ZIKV_DENV.yaml | 33 + .../2024_11_05_A549_TOMM20_ZIKV_DENV.yaml | 29 + .../splits/2024_11_07_A549_SEC61_DENV.yaml | 30 + .../splits/2024_11_21_A549_TOMM20_DENV.yaml | 25 + ...25_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV.yaml | 40 + .../2025_08_26_A549_SEC61_TOMM20_ZIKV.yaml | 47 + .../2026_03_26_A549_CAAX_H2B_DENV_ZIKV.yaml | 154 ++ .../dynacell/a549_assemble_pool.yaml | 106 ++ .../preprocess/dynacell/a549_pack_ozx.yaml | 26 + .../dynacell/nuclei_membrane_selection.yaml | 23 + .../dynacell/organelle_selection.yaml | 29 + .../preprocess/dynacell/segmentation.yaml | 24 + .../_configs/preprocess/update_zarr.yaml | 6 + .../src/dynacell/_manifests/README.md | 24 + .../src/dynacell/_manifests/__init__.py | 17 +- .../a549-mantis-caax-denv-lite/manifest.yaml | 26 + .../splits/caax_train_test.yaml | 27 + .../a549-mantis-caax-denv/manifest.yaml | 6 +- .../splits/caax_train_test.yaml | 12 +- .../a549-mantis-caax-mock-lite/manifest.yaml | 26 + .../splits/caax_train_test.yaml | 27 + .../a549-mantis-caax-mock/manifest.yaml | 6 +- .../a549-mantis-caax-zikv-lite/manifest.yaml | 26 + .../splits/caax_train_test.yaml | 27 + .../a549-mantis-caax-zikv/manifest.yaml | 6 +- .../splits/caax_train_test.yaml | 24 +- .../a549-mantis-h2b-denv-lite/manifest.yaml | 26 + .../splits/h2b_train_test.yaml | 27 + .../a549-mantis-h2b-denv/manifest.yaml | 6 +- .../splits/h2b_train_test.yaml | 12 +- .../a549-mantis-h2b-mock-lite/manifest.yaml | 26 + .../splits/h2b_train_test.yaml | 27 + .../a549-mantis-h2b-mock/manifest.yaml | 6 +- .../a549-mantis-h2b-zikv-lite/manifest.yaml | 26 + .../splits/h2b_train_test.yaml | 27 + .../a549-mantis-h2b-zikv/manifest.yaml | 6 +- .../splits/h2b_train_test.yaml | 24 +- .../manifest.yaml | 26 + .../splits/sec61b_train_test.yaml | 27 + .../a549-mantis-sec61b-denv/manifest.yaml | 6 +- .../splits/sec61b_train_test.yaml | 4 +- .../manifest.yaml | 26 + .../splits/sec61b_train_test.yaml | 27 + .../a549-mantis-sec61b-mock/manifest.yaml | 6 +- .../splits/sec61b_train_test.yaml | 22 +- .../manifest.yaml | 26 + .../splits/sec61b_train_test.yaml | 27 + .../a549-mantis-sec61b-zikv/manifest.yaml | 6 +- .../splits/sec61b_train_test.yaml | 6 +- .../manifest.yaml | 26 + .../splits/tomm20_train_test.yaml | 27 + .../a549-mantis-tomm20-denv/manifest.yaml | 6 +- .../splits/tomm20_train_test.yaml | 10 +- .../manifest.yaml | 26 + .../splits/tomm20_train_test.yaml | 27 + .../a549-mantis-tomm20-mock/manifest.yaml | 6 +- .../splits/tomm20_train_test.yaml | 14 +- .../manifest.yaml | 26 + .../splits/tomm20_train_test.yaml | 27 + .../a549-mantis-tomm20-zikv/manifest.yaml | 6 +- .../splits/tomm20_train_test.yaml | 16 +- .../_manifests/aics-hipsc-lite/manifest.yaml | 58 + .../splits/membrane_train_val_test.yaml | 65 + .../splits/nucleus_train_val_test.yaml | 65 + .../splits/sec61b_train_val_test.yaml | 65 + .../splits/tomm20_train_val_test.yaml | 65 + .../hek-mantis-kras-a549xy/manifest.yaml | 34 + .../splits/kras_train_test.yaml | 24 + .../hek-mantis-tomm70a-a549xy/manifest.yaml | 34 + .../splits/tomm70a_train_test.yaml | 24 + .../dynacell/src/dynacell/celldiff_wrapper.py | 637 ++++++- .../src/dynacell/collections/__init__.py | 20 + .../src/dynacell/collections/freezer.py | 324 ++++ .../src/dynacell/collections/registry.py | 71 + .../src/dynacell/croissant/__init__.py | 23 + .../src/dynacell/croissant/builder.py | 460 +++++ .../dynacell/src/dynacell/croissant/cli.py | 589 +++++++ .../dynacell/src/dynacell/croissant/static.py | 107 ++ .../src/dynacell/croissant/validate.py | 44 + .../dynacell/src/dynacell/data/README.md | 25 + .../dynacell/src/dynacell/data/__init__.py | 8 + .../dynacell/src/dynacell/data/manifests.py | 62 +- .../dynacell/src/dynacell/data/registry.py | 128 ++ .../dynacell/src/dynacell/data/resolver.py | 6 +- .../src/dynacell/distribution/__init__.py | 22 + .../dynacell/src/dynacell/distribution/cli.py | 180 ++ .../src/dynacell/distribution/manifest.py | 102 ++ .../dynacell/src/dynacell/distribution/ozx.py | 320 ++++ .../src/dynacell/distribution/sync.py | 69 + .../src/dynacell/distribution/verify.py | 123 ++ applications/dynacell/src/dynacell/engine.py | 1329 ++++++++++++-- .../src/dynacell/evaluation/CLAUDE.md | 148 +- .../src/dynacell/evaluation/README.md | 533 +++--- .../dynacell/evaluation/_configs/eval.yaml | 116 +- .../evaluation/_configs/eval_grouped.yaml | 3 + .../feature_extractor/morphem/default.yaml | 8 + .../evaluation/_configs/precompute.yaml | 14 + .../src/dynacell/evaluation/_ref_hook.py | 27 +- .../dynacell/src/dynacell/evaluation/cache.py | 462 +++-- .../dynacell/evaluation/cp_features_test.py | 159 ++ .../src/dynacell/evaluation/cp_reference.py | 1114 ++++++++++++ .../dynacell/evaluation/cp_reference_test.py | 683 ++++++++ .../evaluation/cross_condition_probe.py | 202 ++- .../dynacell/evaluation/feature_metrics.py | 127 +- .../evaluation/feature_metrics_test.py | 180 ++ .../src/dynacell/evaluation/feature_select.py | 64 +- .../evaluation/feature_select_test.py | 75 +- .../dynacell/src/dynacell/evaluation/focus.py | 250 ++- .../src/dynacell/evaluation/focus_test.py | 107 ++ .../src/dynacell/evaluation/formatting.py | 67 - .../evaluation/instance_metrics_test.py | 42 + .../dynacell/src/dynacell/evaluation/io.py | 200 --- .../src/dynacell/evaluation/metrics.py | 636 ++++++- .../src/dynacell/evaluation/model_loader.py | 44 +- .../dynacell/src/dynacell/evaluation/paths.py | 1554 +++++++++++++++++ .../src/dynacell/evaluation/pipeline.py | 1411 ++++++++++++--- .../src/dynacell/evaluation/pipeline_cache.py | 968 ++++++++-- .../evaluation/pixel_scaling_backfill.py | 341 ++++ .../evaluation/pixel_scaling_backfill_test.py | 88 + .../src/dynacell/evaluation/precompute_cli.py | 291 ++- .../src/dynacell/evaluation/provenance.py | 357 ++++ .../dynacell/evaluation/provenance_test.py | 302 ++++ .../src/dynacell/evaluation/runtime.py | 8 +- .../src/dynacell/evaluation/save_paths.py | 216 --- .../src/dynacell/evaluation/segmentation.py | 103 +- .../evaluation/segmentation_cellpose.py | 44 +- .../evaluation/segmentation_cpdino.py | 160 ++ .../evaluation/segmentation_cpdino_test.py | 257 +++ .../dynacell/evaluation/segmentation_test.py | 118 ++ .../evaluation/segmentation_whole_cell.py | 11 +- .../evaluation/spectral_pcc/simulate_beads.py | 12 - .../dynacell/src/dynacell/evaluation/utils.py | 184 +- .../src/dynacell/mask_conditioning.py | 233 +++ .../src/dynacell/preprocess/__init__.py | 26 +- .../preprocess/a549_mantis/__init__.py | 57 + .../preprocess/a549_mantis/assemble.py | 1143 ++++++++++++ .../preprocess/a549_mantis/authoring.py | 81 + .../preprocess/a549_mantis/channels.py | 218 +++ .../a549_mantis/generate_pool_manifests.py | 366 ++++ .../dynacell/preprocess/a549_mantis/grid.py | 119 ++ .../src/dynacell/preprocess/segmentation.py | 136 ++ .../src/dynacell/preprocess/selection.py | 196 +++ .../src/dynacell/preprocess/workflow.py | 37 + .../src/dynacell/preprocess/zarr_utils.py | 4 +- .../dynacell/src/dynacell/reporting/cli.py | 2 +- .../dynacell/src/dynacell/reporting/tables.py | 40 +- applications/dynacell/src/dynacell/tiling.py | 53 + applications/dynacell/tests/README.md | 31 + applications/dynacell/tests/_eval_fixtures.py | 61 + .../data/_generate_pixel_metrics_golden.py | 10 +- .../tests/data/pixel_metrics_golden.npz | Bin 6731137 -> 6731575 bytes .../generate_celldiff_trajectory_eval.py | 190 ++ .../tests/test_a549_mantis_assembly.py | 767 ++++++++ .../dynacell/tests/test_bake_best_ckpt.py | 93 + .../test_benchmark_config_composition.py | 899 +++++++++- .../dynacell/tests/test_cli_routing.py | 2 +- .../dynacell/tests/test_collections.py | 688 ++++++++ .../dynacell/tests/test_cp_feature_names.py | 108 ++ applications/dynacell/tests/test_croissant.py | 359 ++++ .../tests/test_cross_condition_probe.py | 208 +++ .../dynacell/tests/test_dataset_ref.py | 107 ++ .../dynacell/tests/test_distribution.py | 660 +++++++ applications/dynacell/tests/test_engine.py | 1031 ++++++++++- .../dynacell/tests/test_evaluate_compose.py | 264 ++- .../dynacell/tests/test_evaluation_cache.py | 190 +- ...st_evaluation_cp_cache_minmax_migration.py | 185 ++ .../tests/test_evaluation_cp_end_to_end.py | 384 ++++ .../test_evaluation_cp_scaler_selection.py | 216 +++ .../tests/test_evaluation_extractors.py | 181 +- .../tests/test_evaluation_fid_provenance.py | 72 + .../dynacell/tests/test_evaluation_focus2d.py | 417 +++++ .../test_evaluation_foreground_metrics.py | 326 ++++ .../test_evaluation_foreground_pipeline.py | 177 ++ .../dynacell/tests/test_evaluation_grouped.py | 323 ++++ .../dynacell/tests/test_evaluation_io.py | 102 -- .../tests/test_evaluation_light_imports.py | 36 + .../dynacell/tests/test_evaluation_metrics.py | 252 ++- .../test_evaluation_microssim_calibration.py | 199 +++ .../tests/test_evaluation_pipeline.py | 43 +- .../test_evaluation_pipeline_parallel.py | 61 +- .../test_evaluation_pipeline_parallel_cpu.py | 172 ++ .../tests/test_evaluation_plot_metrics.py | 107 ++ .../tests/test_evaluation_precompute_cli.py | 36 +- .../test_evaluation_pred_cache_identity.py | 766 ++++++++ .../tests/test_evaluation_timepoint_guard.py | 383 ++++ .../tests/test_generate_pool_manifests.py | 69 + .../dynacell/tests/test_hydra_ref_hook.py | 54 + .../dynacell/tests/test_main_cli_routing.py | 36 + .../dynacell/tests/test_manifest_sync.py | 137 -- .../dynacell/tests/test_migration_tools.py | 361 ++++ applications/dynacell/tests/test_paths.py | 845 +++++++++ .../dynacell/tests/test_pipeline_cache.py | 824 ++++++++- .../tests/test_pixel_metrics_parity.py | 53 +- .../tests/test_preprocess_segmentation.py | 178 ++ .../tests/test_preprocess_selection.py | 87 + .../tests/test_preprocess_workflow.py | 35 + applications/dynacell/tests/test_registry.py | 137 ++ .../tests/test_reporting_tables_extended.py | 35 + .../tests/test_restandardize_config_paths.py | 172 ++ .../dynacell/tests/test_save_paths.py | 71 - .../tests/test_submit_benchmark_batch.py | 107 +- .../tests/test_submit_benchmark_job.py | 759 +++++++- .../tests/test_training_integration.py | 959 +++++++++- applications/dynacell/tools/README.md | 49 + .../dynacell/tools/RELEASING_CHECKPOINTS.md | 119 ++ .../add_instance_ap_to_ablation_leaves.py | 32 +- .../tools/assemble_release_checkpoints.py | 437 +++++ .../assemble_release_checkpoints_test.py | 97 + applications/dynacell/tools/bake_best_ckpt.py | 179 ++ .../dynacell/tools/build_cp_reference.py | 352 ++++ .../dynacell/tools/build_cp_reference_test.py | 285 +++ .../tools/build_cpdino_seg_cleaned.py | 268 +++ .../tools/build_cpdino_seg_cleaned.slurm | 53 + .../dynacell/tools/build_hek_eval_stores.py | 345 ++++ .../tools/build_migration_manifest.py | 531 ++++++ .../tools/build_temporal_subset_zarr.py | 556 ++++++ .../tools/build_temporal_subset_zarr_test.py | 329 ++++ applications/dynacell/tools/evaluate_batch.sh | 93 - applications/dynacell/tools/evaluate_local.sh | 223 --- .../tools/extract_focus_slab_store.py | 375 ++++ .../tools/extract_focus_slab_store_test.py | 247 +++ .../tools/generate_grouped_eval_configs.py | 713 +++++--- .../generate_grouped_eval_configs_test.py | 428 +++-- .../tools/generate_hek_predict_configs.py | 360 ++++ .../generate_instance_ap_eval_configs.py | 114 +- .../generate_instance_ap_eval_configs_test.py | 47 +- .../tools/generate_lite_benchmark_configs.py | 412 +++++ .../generate_lite_benchmark_configs_test.py | 252 +++ applications/dynacell/tools/lite_checks.py | 419 +++++ .../dynacell/tools/lite_checks_test.py | 147 ++ applications/dynacell/tools/lite_compare.py | 242 +++ .../dynacell/tools/lite_compare_test.py | 132 ++ .../dynacell/tools/lite_subset_sim.py | 597 +++++++ .../dynacell/tools/lite_subset_sim_test.py | 224 +++ .../tools/make_carved_membrane_leaves.py | 65 - .../tools/restandardize_config_paths.py | 252 +++ .../tools/retokenize_deconv_predictions.py | 555 ++++++ .../retokenize_deconv_predictions_test.py | 268 +++ .../dynacell/tools/run_eval_direct.slurm | 32 +- applications/dynacell/tools/run_migration.py | 292 ++++ .../dynacell/tools/sbatch_template.sbatch | 15 +- .../tools/sbatch_template_array.sbatch | 6 +- .../tools/scan_nan_microssim_caches.py | 79 + .../tools/scan_nan_microssim_caches_test.py | 57 + .../dynacell/tools/submit_benchmark_batch.py | 56 +- .../dynacell/tools/submit_benchmark_job.py | 511 +++++- .../dynacell/tools/submit_evaluation_batch.py | 406 ----- .../dynacell/tools/submit_evaluation_job.py | 252 --- .../dynacell/tools/watch_stalled_jobs.py | 400 +++++ .../dynacell/tools/watch_stalled_jobs_test.py | 589 +++++++ 297 files changed, 54921 insertions(+), 4438 deletions(-) create mode 100644 applications/dynacell/CITATION.cff create mode 100644 applications/dynacell/docs/evaluating-external-checkpoints.md create mode 100644 applications/dynacell/examples/README.md create mode 100644 applications/dynacell/examples/hf_demo/build_demo_data.py create mode 100644 applications/dynacell/examples/hf_demo/build_demo_data_test.py create mode 100644 applications/dynacell/examples/hf_demo/upload_demo_data.py create mode 100644 applications/dynacell/src/README.md create mode 100644 applications/dynacell/src/dynacell/README.md create mode 100644 applications/dynacell/src/dynacell/_configs/collections/virtual_staining/membrane_ipsc_v1.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/collections/virtual_staining/membrane_joint_all_v1.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/collections/virtual_staining/membrane_joint_mock_v1.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/collections/virtual_staining/nucleus_ipsc_v1.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/collections/virtual_staining/nucleus_joint_all_v1.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/collections/virtual_staining/nucleus_joint_mock_v1.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/collections/virtual_staining/sec61b_ipsc_v1.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/collections/virtual_staining/sec61b_joint_all_v1.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/collections/virtual_staining/sec61b_joint_mock_v1.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/collections/virtual_staining/tomm20_joint_all_v1.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/collections/virtual_staining/tomm20_joint_mock_v1.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_10_29_A549_TOMM20_ZIKV_DENV.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_10_31_A549_SEC61_ZIKV_DENV.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_11_05_A549_TOMM20_ZIKV_DENV.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_11_07_A549_SEC61_DENV.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_11_21_A549_TOMM20_DENV.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2025_08_26_A549_SEC61_TOMM20_ZIKV.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2026_03_26_A549_CAAX_H2B_DENV_ZIKV.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_10_29_A549_TOMM20_ZIKV_DENV.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_10_31_A549_SEC61_ZIKV_DENV.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_11_05_A549_TOMM20_ZIKV_DENV.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_11_07_A549_SEC61_DENV.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_11_21_A549_TOMM20_DENV.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2025_08_26_A549_SEC61_TOMM20_ZIKV.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2026_03_26_A549_CAAX_H2B_DENV_ZIKV.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/preprocess/dynacell/a549_assemble_pool.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/preprocess/dynacell/a549_pack_ozx.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/preprocess/dynacell/nuclei_membrane_selection.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/preprocess/dynacell/organelle_selection.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/preprocess/dynacell/segmentation.yaml create mode 100644 applications/dynacell/src/dynacell/_configs/preprocess/update_zarr.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/README.md create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-denv-lite/manifest.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-denv-lite/splits/caax_train_test.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-mock-lite/manifest.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-mock-lite/splits/caax_train_test.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-zikv-lite/manifest.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-zikv-lite/splits/caax_train_test.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-denv-lite/manifest.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-denv-lite/splits/h2b_train_test.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-mock-lite/manifest.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-mock-lite/splits/h2b_train_test.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-zikv-lite/manifest.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-zikv-lite/splits/h2b_train_test.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-denv-lite/manifest.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-denv-lite/splits/sec61b_train_test.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-mock-lite/manifest.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-mock-lite/splits/sec61b_train_test.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-zikv-lite/manifest.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-zikv-lite/splits/sec61b_train_test.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-denv-lite/manifest.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-denv-lite/splits/tomm20_train_test.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-mock-lite/manifest.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-mock-lite/splits/tomm20_train_test.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-zikv-lite/manifest.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-zikv-lite/splits/tomm20_train_test.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/manifest.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/splits/membrane_train_val_test.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/splits/nucleus_train_val_test.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/splits/sec61b_train_val_test.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/splits/tomm20_train_val_test.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/hek-mantis-kras-a549xy/manifest.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/hek-mantis-kras-a549xy/splits/kras_train_test.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/hek-mantis-tomm70a-a549xy/manifest.yaml create mode 100644 applications/dynacell/src/dynacell/_manifests/hek-mantis-tomm70a-a549xy/splits/tomm70a_train_test.yaml create mode 100644 applications/dynacell/src/dynacell/collections/__init__.py create mode 100644 applications/dynacell/src/dynacell/collections/freezer.py create mode 100644 applications/dynacell/src/dynacell/collections/registry.py create mode 100644 applications/dynacell/src/dynacell/croissant/__init__.py create mode 100644 applications/dynacell/src/dynacell/croissant/builder.py create mode 100644 applications/dynacell/src/dynacell/croissant/cli.py create mode 100644 applications/dynacell/src/dynacell/croissant/static.py create mode 100644 applications/dynacell/src/dynacell/croissant/validate.py create mode 100644 applications/dynacell/src/dynacell/data/README.md create mode 100644 applications/dynacell/src/dynacell/data/registry.py create mode 100644 applications/dynacell/src/dynacell/distribution/__init__.py create mode 100644 applications/dynacell/src/dynacell/distribution/cli.py create mode 100644 applications/dynacell/src/dynacell/distribution/manifest.py create mode 100644 applications/dynacell/src/dynacell/distribution/ozx.py create mode 100644 applications/dynacell/src/dynacell/distribution/sync.py create mode 100644 applications/dynacell/src/dynacell/distribution/verify.py create mode 100644 applications/dynacell/src/dynacell/evaluation/_configs/feature_extractor/morphem/default.yaml create mode 100644 applications/dynacell/src/dynacell/evaluation/cp_reference.py create mode 100644 applications/dynacell/src/dynacell/evaluation/cp_reference_test.py create mode 100644 applications/dynacell/src/dynacell/evaluation/focus_test.py delete mode 100644 applications/dynacell/src/dynacell/evaluation/formatting.py delete mode 100644 applications/dynacell/src/dynacell/evaluation/io.py create mode 100644 applications/dynacell/src/dynacell/evaluation/paths.py create mode 100644 applications/dynacell/src/dynacell/evaluation/pixel_scaling_backfill.py create mode 100644 applications/dynacell/src/dynacell/evaluation/pixel_scaling_backfill_test.py create mode 100644 applications/dynacell/src/dynacell/evaluation/provenance.py create mode 100644 applications/dynacell/src/dynacell/evaluation/provenance_test.py delete mode 100644 applications/dynacell/src/dynacell/evaluation/save_paths.py create mode 100644 applications/dynacell/src/dynacell/evaluation/segmentation_cpdino.py create mode 100644 applications/dynacell/src/dynacell/evaluation/segmentation_cpdino_test.py create mode 100644 applications/dynacell/src/dynacell/evaluation/segmentation_test.py create mode 100644 applications/dynacell/src/dynacell/mask_conditioning.py create mode 100644 applications/dynacell/src/dynacell/preprocess/a549_mantis/__init__.py create mode 100644 applications/dynacell/src/dynacell/preprocess/a549_mantis/assemble.py create mode 100644 applications/dynacell/src/dynacell/preprocess/a549_mantis/authoring.py create mode 100644 applications/dynacell/src/dynacell/preprocess/a549_mantis/channels.py create mode 100644 applications/dynacell/src/dynacell/preprocess/a549_mantis/generate_pool_manifests.py create mode 100644 applications/dynacell/src/dynacell/preprocess/a549_mantis/grid.py create mode 100644 applications/dynacell/src/dynacell/preprocess/segmentation.py create mode 100644 applications/dynacell/src/dynacell/preprocess/selection.py create mode 100644 applications/dynacell/src/dynacell/preprocess/workflow.py create mode 100644 applications/dynacell/src/dynacell/tiling.py create mode 100644 applications/dynacell/tests/README.md create mode 100644 applications/dynacell/tests/generate_celldiff_trajectory_eval.py create mode 100644 applications/dynacell/tests/test_a549_mantis_assembly.py create mode 100644 applications/dynacell/tests/test_bake_best_ckpt.py create mode 100644 applications/dynacell/tests/test_collections.py create mode 100644 applications/dynacell/tests/test_cp_feature_names.py create mode 100644 applications/dynacell/tests/test_croissant.py create mode 100644 applications/dynacell/tests/test_cross_condition_probe.py create mode 100644 applications/dynacell/tests/test_distribution.py create mode 100644 applications/dynacell/tests/test_evaluation_cp_cache_minmax_migration.py create mode 100644 applications/dynacell/tests/test_evaluation_cp_end_to_end.py create mode 100644 applications/dynacell/tests/test_evaluation_cp_scaler_selection.py create mode 100644 applications/dynacell/tests/test_evaluation_fid_provenance.py create mode 100644 applications/dynacell/tests/test_evaluation_focus2d.py create mode 100644 applications/dynacell/tests/test_evaluation_foreground_metrics.py create mode 100644 applications/dynacell/tests/test_evaluation_foreground_pipeline.py delete mode 100644 applications/dynacell/tests/test_evaluation_io.py create mode 100644 applications/dynacell/tests/test_evaluation_light_imports.py create mode 100644 applications/dynacell/tests/test_evaluation_microssim_calibration.py create mode 100644 applications/dynacell/tests/test_evaluation_plot_metrics.py create mode 100644 applications/dynacell/tests/test_evaluation_pred_cache_identity.py create mode 100644 applications/dynacell/tests/test_evaluation_timepoint_guard.py create mode 100644 applications/dynacell/tests/test_generate_pool_manifests.py create mode 100644 applications/dynacell/tests/test_main_cli_routing.py delete mode 100644 applications/dynacell/tests/test_manifest_sync.py create mode 100644 applications/dynacell/tests/test_migration_tools.py create mode 100644 applications/dynacell/tests/test_paths.py create mode 100644 applications/dynacell/tests/test_preprocess_segmentation.py create mode 100644 applications/dynacell/tests/test_preprocess_selection.py create mode 100644 applications/dynacell/tests/test_preprocess_workflow.py create mode 100644 applications/dynacell/tests/test_registry.py create mode 100644 applications/dynacell/tests/test_restandardize_config_paths.py delete mode 100644 applications/dynacell/tests/test_save_paths.py create mode 100644 applications/dynacell/tools/README.md create mode 100644 applications/dynacell/tools/RELEASING_CHECKPOINTS.md create mode 100644 applications/dynacell/tools/assemble_release_checkpoints.py create mode 100644 applications/dynacell/tools/assemble_release_checkpoints_test.py create mode 100644 applications/dynacell/tools/bake_best_ckpt.py create mode 100644 applications/dynacell/tools/build_cp_reference.py create mode 100644 applications/dynacell/tools/build_cp_reference_test.py create mode 100644 applications/dynacell/tools/build_cpdino_seg_cleaned.py create mode 100644 applications/dynacell/tools/build_cpdino_seg_cleaned.slurm create mode 100644 applications/dynacell/tools/build_hek_eval_stores.py create mode 100644 applications/dynacell/tools/build_migration_manifest.py create mode 100644 applications/dynacell/tools/build_temporal_subset_zarr.py create mode 100644 applications/dynacell/tools/build_temporal_subset_zarr_test.py delete mode 100755 applications/dynacell/tools/evaluate_batch.sh delete mode 100755 applications/dynacell/tools/evaluate_local.sh create mode 100644 applications/dynacell/tools/extract_focus_slab_store.py create mode 100644 applications/dynacell/tools/extract_focus_slab_store_test.py create mode 100644 applications/dynacell/tools/generate_hek_predict_configs.py create mode 100644 applications/dynacell/tools/generate_lite_benchmark_configs.py create mode 100644 applications/dynacell/tools/generate_lite_benchmark_configs_test.py create mode 100644 applications/dynacell/tools/lite_checks.py create mode 100644 applications/dynacell/tools/lite_checks_test.py create mode 100644 applications/dynacell/tools/lite_compare.py create mode 100644 applications/dynacell/tools/lite_compare_test.py create mode 100644 applications/dynacell/tools/lite_subset_sim.py create mode 100644 applications/dynacell/tools/lite_subset_sim_test.py delete mode 100644 applications/dynacell/tools/make_carved_membrane_leaves.py create mode 100644 applications/dynacell/tools/restandardize_config_paths.py create mode 100644 applications/dynacell/tools/retokenize_deconv_predictions.py create mode 100644 applications/dynacell/tools/retokenize_deconv_predictions_test.py create mode 100644 applications/dynacell/tools/run_migration.py create mode 100644 applications/dynacell/tools/scan_nan_microssim_caches.py create mode 100644 applications/dynacell/tools/scan_nan_microssim_caches_test.py delete mode 100755 applications/dynacell/tools/submit_evaluation_batch.py delete mode 100755 applications/dynacell/tools/submit_evaluation_job.py create mode 100644 applications/dynacell/tools/watch_stalled_jobs.py create mode 100644 applications/dynacell/tools/watch_stalled_jobs_test.py diff --git a/applications/dynacell/.gitignore b/applications/dynacell/.gitignore index 0cc49df5c..15c39384f 100644 --- a/applications/dynacell/.gitignore +++ b/applications/dynacell/.gitignore @@ -1,3 +1,6 @@ lightning_logs/ outputs/ __pycache__/ + +# Investigations, ablations and checks: one dated directory each, never tracked +experiments/ diff --git a/applications/dynacell/CITATION.cff b/applications/dynacell/CITATION.cff new file mode 100644 index 000000000..56c6b4d9b --- /dev/null +++ b/applications/dynacell/CITATION.cff @@ -0,0 +1,117 @@ +cff-version: 1.2.0 +title: "DynaCell: An Evaluation Framework for Dynamic 3D Virtual Staining of Live Cells" +message: >- + If you use DynaCell (code, data, or trained checkpoints), please cite the + paper listed under preferred-citation. +type: software +authors: + - given-names: Alexandr A. + family-names: Kalinin + affiliation: Biohub, San Francisco + - given-names: Dihan + family-names: Zheng + affiliation: University of California, San Francisco + - given-names: Taylla Milena + family-names: Theodoro + affiliation: Biohub, San Francisco + - given-names: Ivan + family-names: Ivanov + affiliation: Biohub, San Francisco + - given-names: Eduardo + family-names: Hirata-Miyasaki + affiliation: Biohub, San Francisco + - given-names: See-Chi + family-names: Lee + affiliation: Biohub, San Francisco + - given-names: Aofei + family-names: Liu + affiliation: Biohub, San Francisco + - given-names: Sricharan Reddy + family-names: Varra + affiliation: Biohub, San Francisco + - given-names: Talon + family-names: Chandler + affiliation: Biohub, San Francisco + - given-names: Soorya + family-names: Pradeep + affiliation: Biohub, San Francisco + - given-names: Chad + family-names: Liu + affiliation: Biohub, San Francisco + - given-names: Manuel D. + family-names: Leonetti + affiliation: Biohub, San Francisco + - given-names: Carolina + family-names: Arias + affiliation: Biohub, San Francisco + - given-names: Bo + family-names: Huang + affiliation: University of California, San Francisco + - given-names: Shalin B. + family-names: Mehta + affiliation: Biohub, San Francisco +repository-code: "https://github.com/mehta-lab/VisCy" +license: BSD-3-Clause +abstract: >- + DynaCell is an evaluation framework for 3D time-lapse virtual staining of + live cells. It combines paired 3D time-lapse images acquired with and without + fluorescent labels, a suite of baseline models, and three metric tiers that + measure pixel-level fidelity, organelle segmentation performance, and + single-cell phenotype similarity. +keywords: + - virtual staining + - live-cell imaging + - benchmarking + - microscopy + - deep learning +preferred-citation: + type: conference-paper + title: "DynaCell: An Evaluation Framework for Dynamic 3D Virtual Staining of Live Cells" + collection-title: "Advances in Neural Information Processing Systems (NeurIPS 2026), Evaluations and Datasets Track" + year: 2026 + authors: + - given-names: Alexandr A. + family-names: Kalinin + affiliation: Biohub, San Francisco + - given-names: Dihan + family-names: Zheng + affiliation: University of California, San Francisco + - given-names: Taylla Milena + family-names: Theodoro + affiliation: Biohub, San Francisco + - given-names: Ivan + family-names: Ivanov + affiliation: Biohub, San Francisco + - given-names: Eduardo + family-names: Hirata-Miyasaki + affiliation: Biohub, San Francisco + - given-names: See-Chi + family-names: Lee + affiliation: Biohub, San Francisco + - given-names: Aofei + family-names: Liu + affiliation: Biohub, San Francisco + - given-names: Sricharan Reddy + family-names: Varra + affiliation: Biohub, San Francisco + - given-names: Talon + family-names: Chandler + affiliation: Biohub, San Francisco + - given-names: Soorya + family-names: Pradeep + affiliation: Biohub, San Francisco + - given-names: Chad + family-names: Liu + affiliation: Biohub, San Francisco + - given-names: Manuel D. + family-names: Leonetti + affiliation: Biohub, San Francisco + - given-names: Carolina + family-names: Arias + affiliation: Biohub, San Francisco + - given-names: Bo + family-names: Huang + affiliation: University of California, San Francisco + - given-names: Shalin B. + family-names: Mehta + affiliation: Biohub, San Francisco diff --git a/applications/dynacell/CLAUDE.md b/applications/dynacell/CLAUDE.md index 24f1166b0..12a75fa9b 100644 --- a/applications/dynacell/CLAUDE.md +++ b/applications/dynacell/CLAUDE.md @@ -5,16 +5,41 @@ Config keys, prediction-zarr filenames, eval keys, and W&B run names use **code names**; figures/tables/manuscripts use **paper names**. Translate at any code/paper boundary. This table is the source of truth (referenced by -`src/dynacell/evaluation/save_paths.py:PAPER_KEY`). +`src/dynacell/evaluation/paths.py:PAPER_KEY`). | Code name | Paper name | | --- | --- | | `fcmae_vscyto3d_scratch` | **UNeXt2** | | `fcmae_vscyto3d_pretrained` | **VSCyto3D** (FCMAE-pretrained UNeXt2) | -| `unetvit3d` | **UNetViT3D** (deterministic; iPSC-trained only) | +| `unetvit3d` | **UNetViT3D** (deterministic; iPSC-trained for nucleus/membrane; ER/mito also have a549/joint checkpoints from the A549 raw-regen campaign gap-fill) | | `pix2pix3d_unetvit` | **pix2pix3d** (GAN; same UNetViT3D generator, `DynacellGAN` engine) | | `fnet3d_paper` | **FNet3D** | | `celldiff` / `celldiff_r2` | **CELL-Diff** (variants: `iterative`, `sliding_window`, `denoise`/Mean Predictor) | +| `fcmae_vscyto2d_scratch` | **UNeXt2-2D** (in-focus 2D track) | +| `fcmae_vscyto2d_pretrained` | **VSCyto2D** (encoder init from the public 2D FCMAE ckpt) | +| `fnet2d` | **FNet2D** | +| `celldiff_2d` | **CellDiff-2D** (CELLDiffNet run Z-preserving at Z=1) | +| `pix2pix2d_unetvit` | **pix2pix2d** (same GAN, UNetViT generator + PatchGAN both run Z-preserving at Z=1) | + +The five 2D keys are the in-focus 2D-vs-3D benchmark track. Their paper names are +deliberately distinct from the 3D namesakes (`unext2_2d` vs `unext2`, `vscyto2d` vs +`vscyto3d`, `celldiff_2d` vs `celldiff_r2`, `pix2pix2d` vs `pix2pix3d`) — collapsing them +would merge the 2D and 3D rows into one eval dir. `celldiff_2d` is in `_CELLDIFF_MODELS` +(not `_DETERMINISTIC_MODELS`) because it is flow-matching like its 3D counterpart; the +tuple is ordered longest-first so prefix matching cannot truncate it to bare `celldiff`. +`pix2pix2d_unetvit` goes in `_DETERMINISTIC_MODELS` for the same reason +`pix2pix3d_unetvit` does — a GAN generator is a single deterministic forward at +inference, and the sampling variants that tuple guards against are CellDiff's. + +⚠ **The published pix2pix3d weights were NOT trained by the overlay its `train.yml` +leaves compose.** `train.yml` binds the LSGAN baseline +(`pix2pix3d_unetvit_fit.yml`); the weights came from the 12 +`train_4gpu_modernized.yml` leaves, i.e. Run D — checkpoint `hyper_parameters` read +`loss_type='nonsat'`, `lr_g=lr_d=2e-4`, `r1_gamma=10`, `ema_kimg=10`, +`lecam_gamma=0.3`, `lambda_l1=10`, plus 201 `generator_ema.*` tensors and +`max_epochs: 40`. `pix2pix2d_unetvit_fit.yml` mirrors Run D so the 2D-vs-3D comparison +isolates geometry, and bakes the three Run-D deltas instead of repeating them per leaf. +Read a checkpoint's own hparams before assuming a leaf's overlay is what ran. VSCyto3D ablations (in `vscyto3d-ablations`): `*_randinit` (untrained), `*_cytoland` (public ckpt, no FT), `*_infectionft` (cytoland→A549-infection-FT, @@ -22,6 +47,27 @@ no FT), `vscyto3d_cytolandft` / `vscyto3d_infectionft_dynacellft` (+ dynacell FT dual nucleus+membrane). The same suffixes appear as zarr-filename infixes; `_cytolandft` / `_infectionft_dynacellft` combine with `_a549trained`. +## Training data: A549 condition pooling + +A549 training data is **condition-pooled**: both joint (iPSC+A549) and A549-only fits +read a single `_all.zarr` per target combining **mock + ZIKV + DENV** (not +mock-only), at +`/hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/{H2B,CAAX,SEC61B,TOMM20}_all.zarr`. +Built by `assemble.py` (paper repo `dynacell_paper/preprocess/a549_mantis/`) with +`condition=None`, so its per-condition position filter drops nothing — it walks every +train-split position across all three conditions. + +- The pooled store is a single flattened well (`0/0`) with sequential FOV names + (`fov0000…`); the **condition is dropped from the FOV name**, so you cannot read the + conditions off the on-disk layout — only from the build script / config comment. +- There is **no `*joint*` train-set fragment** — joint train leaves compose + `_internal/shared/model/train_sets/{a549_mantis,ipsc_confocal}.yml` and author the two + `HCSDataModule` children of `BatchedConcatDataModule` inline (A549 child → + `_all.zarr`, iPSC child → `ipsc/dataset_v4/train/cell.zarr`). +- Deliberate asymmetry: **train pools conditions; predict/eval stays per-condition** + (canonical per-treatment `.ozx` in the manifest registry) — hence test sets and the + paper tables break out mock/denv/zikv. + ## Prediction zarr naming Set by `trainer.callbacks[…HCSPredictionWriter].init_args.output_store` in each @@ -50,12 +96,53 @@ Two exceptions to watch: `_celldiff_r2[_].zarr`. Sweeps that only walk `predictions/` miss them. FCMAE/fnet3d joint zarrs in the same dir do follow `_jointtrained_`. +## Re-predict completeness: gate on chunk mtime, never chunk count + +`--overwrite` makes `HCSPredictionWriter` rewrite the prediction channel **in +place**. It never deletes the previous run's chunks, so every count-based +completeness gate reads FULL from the first second of the run. + +Measured 2026-09-11 on the 36 CellDiff-2D A549 re-predicts: counting chunks said +**432/432 FOVs complete across all 36 stores** while all 36 jobs were still +`RUNNING` — which looks exactly like the post-completion hang in the root +CLAUDE.md. It was not. An mtime split put `er/celldiff_2d/a549/a549__denv` at +fov0010 213/480 with fov0011 untouched and **748 chunks still carrying the +previous run's mtimes**; the true mean across the 36 was ~55%, not 100%. + +The gate that works — count only chunks this run wrote: + +```sh +find $STORE/0/0 -path '*/0/c/*' -type f -newermt '' | wc -l +``` + +against `n_fov * T * Z`. Three things that make a naive version wrong: + +- **Read `T` from each FOV's own `zarr.json` `shape[0]`.** It varies *within* one + plate — 7 and 10 both occur in the same A549 prediction store — so one `T` for + the whole store over- or under-counts. +- **The chunk path under `c/` is `////`.** `c/2/0/47/0/0` is + **timepoint 2**, z-plane 47 — not channel 2. Reading that index as a channel + makes a 7-timepoint store look like a complete 48-plane one. +- **Comparing declared `T` to the number of timepoint directories present is + circular** on a re-predict: the previous run already created every directory, + so they always match. + +Also restrict the glob to `*/0/c/*` (resolution level 0). `*/c/*` picks up the +multiscale pyramid levels too and reports >100%. + +Separately, a re-predict does **not** invalidate the eval caches — see +`force_recompute` under *Grouped multi-condition eval*. Overwriting a store in +place leaves `final_metrics` happy to rescore masks and embeddings derived from +the old predictions, so a re-predicted bucket needs every `pred_*` +`force_recompute` flag, not just `final_metrics`. + ## Eval directory naming -`src/dynacell/evaluation/save_paths.py:eval_save_dir` is the writer and the -cross-repo contract (must match the paper's -`compute_all_organelle_precision_recall.py:eval_dir_for`; pinned by -`tests/test_save_paths.py`). Canonical focus-2D outputs under +`src/dynacell/evaluation/paths.py` is the writer and the cross-repo contract +(`eval_leaf` for the canonical model-centric layout, `normalize_legacy` for the +pre-canonical `*_with_embeddings` forms; the paper repo vendor-copies it and +asserts parity — must match `compute_all_organelle_precision_recall.py:eval_dir_for`; +pinned by `tests/test_paths.py`). Canonical focus-2D outputs under `/hpc/projects/virtual_staining/training/dynacell/{ipsc,a549}/`: `evaluations_with_embeddings/` (ipsc-trained), `evaluations_a549trained_with_embeddings/`, `evaluations_jointtrained_with_embeddings/` (infix `jointtrained`). Dirs use the @@ -86,6 +173,26 @@ runtime: - `DYNACELL_FORCE_PER_T_HYGIENE=1` — runtime escape hatch to force per-T `cuda_empty_cache` + `gc_collect` without a YAML change. +## Device-agnostic array code (NumPy / CuPy) + +Eval code runs on NumPy or CuPy arrays depending on `use_gpu`. Follow cubic's +rule (`cubic/AGENTS.md`, *Device-Agnostic Code Pattern*): **call `np.` functions +and array methods directly on either kind of array, and avoid the `xp` +array-module interface.** NumPy dispatches `np.isfinite`, `np.abs`, +`np.fft.fftn`, `np.bincount` and the like to CuPy for CuPy inputs, and +`.max()`, `.astype()`, boolean indexing and friends are the same on both. + +- Keep derived arrays (masks, ranges, indices) on the input's device: build them + with `np.`/array methods from the input itself, and never round-trip to the host + just to index back into a device array. +- `get_array_module` (`xp`) only for **creating** a new array that must live on + a given device (`xp.zeros`, `xp.asarray`) or for the rare function NumPy does + not dispatch. +- Move arrays between devices with `cubic.cuda` (`asnumpy`, `ascupy`, + `to_same_device`, `get_device`), never with direct `cupy.*` calls. +- Some older eval modules (`segmentation_whole_cell.py`, `segmentation_cellpose.py`, + `spectral_pcc/evaluate.py`) still use `xp`. Don't copy that into new code. + ## Grouped multi-condition eval For the same `(model, organelle)` across multiple I/O variants (typically the 3 @@ -113,19 +220,41 @@ re-loads models per condition). ## Focus-aware 2D projection (`evaluation/focus.py`) The 3D→2D reduction is focus-aware so projection isn't dominated by out-of-focus -caps (A549 Z=48, in-focus band ~5 planes). Three knobs, all default-off: - -- `feature_metrics.focus_slab.{enabled,halfwidth,channel_name}` — deep-feature - crops + per-cell similarity max-project over a `2*halfwidth+1` slab on the - in-focus plane (CP regionprops stay 3D). Folds `+focusslab_h{h}_{ch}_{sig}` - into each deep-feature `preprocess_version` so embedding caches auto-invalidate - (`{sig}` hashes the `focus.{na_det,lambda_ill,pixel_size}` params). -- `segmentation.slice_selection=focus` — 2D instance seg picks the in-focus plane - (vs the old `frac=0.30`). -- `precompute-gt build.focus=true` — writes `focus_slice` zattrs to a writable GT - store. - -**Plane source (precedence):** (1) precomputed `focus_slice` zattrs (iPSC `.zarr` +caps (A549 Z=48, in-focus band ~5 planes). Four knobs; the first two are on by +default (since 35c0235b, 2026-06-16): + +- `feature_metrics.focus_slab.{enabled,halfwidth,channel_name}` (default on, + halfwidth 2, i.e. 5 planes) — deep-feature crops + per-cell similarity + max-project over a `2*halfwidth+1` slab on the phase in-focus plane (CP + regionprops stay 3D). Folds `+focusslab_h{h}_{ch}_{sig}` into each deep-feature + `preprocess_version` so embedding caches auto-invalidate (`{sig}` hashes the + `focus.{na_det,lambda_ill,pixel_size}` params). +- `segmentation.slice_selection=focus` (default) — 2D instance seg picks the + in-focus plane (vs the old `frac=0.30`). `segmentation.focus_anchor` chooses it: + `nucleus_area` (default, widest GT nuclear cross-section) or `phase_midband` + (the phase estimator below). +- `focus2d.halfwidth` (default null = the 3D benchmark, every metric over the full + volume) — the 2D benchmark: one GT-anchored plane per timepoint + (`segmentation.focus_anchor`) scores every metric. Pixel metrics, MicroMS3IM and CP + on the plane (2D SSIM/Spectral PCC, `FRC_Resolution`); deep features + per-cell + similarity on its `2h+1` slab (overrides `focus_slab`); semantic masks segment the + slab and keep the plane; instance targets must match (`slice_selection=focus`, + `focus_slab_halfwidth=h`). `h=1` is slab3. Caches go to `/focus2d_h/` + (the CP cache key has no z geometry, so sharing would silently reuse 3D rows), CP + uses the `__focus2d_h` reference (`build_cp_reference.py --focus2d h`), + and the recipe is stamped in `metrics_provenance.json`. +- `precompute-gt build.focus_planes=` (needs `focus2d`) — writes the slab of + every position/timepoint as the plane file a 2D model predicts with + (`HCSDataModule.predict_z_planes`): the predict then skips every other plane, and + the writer records the planes so the eval refuses a store that lacks its slab (and + a full-volume eval of such a store). The 2D predict leaves keep `prediction.zarr`; + the writer refuses a slab predict into a store another run wrote (its planes would + survive around the slab), so remove a full-Z store before re-predicting it. +- `precompute-gt build.focus=true` (default false) — writes `focus_slice` zattrs + to a writable GT store. + +**Phase plane source** (the slab and `focus_anchor=phase_midband`) +**(precedence):** (1) precomputed `focus_slice` zattrs (iPSC `.zarr` fast path); (2) `io.gt_cache_dir/focus_planes//.json`; (3) compute from the phase channel + persist. Compute-at-eval-time (3) is why focus works on the **read-only published A549 `.ozx`** — they carry no zattrs and `pack_ozx` @@ -153,3 +282,102 @@ mutually exclusive shapes — pick by parallelism, not familiarity: For local foreground runs, `tools/predict_local.sh --parallel N` backgrounds on the current host's GPU (2-up confirmed on the A40 interactive node) — a different path from the sbatch helper's `--parallel`. + +## DynaCell-lite: the fast test side for model iteration + +A smaller test set that reproduces the full benchmark's model orderings on the selected metrics: +A549 keeps all 12 FOVs per condition at 5 of 10 timepoints (`build_temporal_subset_zarr.py --mode +spread -n 5`), iPSC keeps a seeded 50 of 100 FOVs per GT store. Offline, it retains >= 0.895 of the +model pairs the full benchmark can resolve on every non-GLCM+ selected metric. End to end, a lite eval +reproduces the full benchmark on the same FOVs and frames, measured on 2026-10-01 across all four organelles: +- pixel metrics to <= 7e-5; +- deep KIDs to <= 3.2e-4 relative (median ~3e-5); +- semantic-mask Dice (ER, mito) to <= 6e-5. + +cpdino instance masks (nucleus, membrane) differ by GPU type, because cellpose runs in bf16. Per-row +Dice medians stay <= 3e-4, but a single frame can be off by up to ~0.1. Predict cost is ~0.44x on A549. +Evidence: `experiments/2026-09-14_lite-benchmark-plan/PLAN.md` §11–§15 and +`experiments/2026-09-30_repredict-stale-pred-cache/`. + +- **It is a separate dataset, never an override of the full one.** Every per-timepoint artifact + (segmentation store, GT feature cache `{pos}/t{t}`, focus cache) is indexed by its store's own `t`, + so sharing a cache would score subset frame k against full frame k, and a T-mismatched write + deletes the full cache arrays in place. The eval now refuses per-position T mismatches between + pred, GT, segmentation and nuclei stores. +- **Isolation is by root.** Everything lite lives under `paths.LITE_DATA_ROOT` + (`/hpc/projects/virtual_staining/training/dynacell_lite`), laid out exactly like `DATA_ROOT`; use the + grammar functions with `data_root=LITE_DATA_ROOT`. Datasets are the `*-lite` manifests. +- **Configs are generated, never hand-edited:** `tools/generate_lite_benchmark_configs.py` derives the + lite manifests, predict sets, `predict___lite.yml` leaves (same checkpoint as the production + leaf) and `leaf/grouped/__lite/` eval leaves from their production siblings, and a test pins + the committed files to its output. To put a new model on the lite: give it a production predict + leaf, add its dir to `ROSTER_MODELS`, regenerate, then predict with `submit_benchmark_batch.py + --array --allow-mixed-directives` and evaluate with `tools/run_eval_direct.slurm + grouped/__lite/eval_grouped`. +- **Reported metrics:** si-SSIM, Spectral PCC, Dice, the five deep KIDs and cosines. GLCM+ KID is + dropped (biased low at lite cell counts); GLCM+ cosine is kept but flagged. MicroSSIM, FID, PRC and + MIND are off (`compute_microssim`, `feature_metrics.compute_{fid,prc,mind}`). +- **A549 has no separate nuclei store**: `nuclei_gt_path` is the GT store itself, so lite membrane + leaves omit it and the carve reads nuclei from the lite GT store. +- **CELL-Diff runs a fast recipe on the lite** (`model_overlays/celldiff_predict_lite.yml`), so a lite + CELL-Diff prediction is a different sample, not a subset of the production one. It keeps + production's tile grid (512^2 tiles, YX overlap 256, iterative anchoring) and changes: + - Z overlap 4 -> 2; + - adaptive dopri5 (~56-66 velocity evaluations per tile) -> midpoint on a Beta(0.4, 0.3) time grid, + 14 evaluations, packed toward the data end; + - bf16 + `torch.compile` of a channels-last copy of the net, with `cudnn.benchmark`. + + One fit's whole lite test set: 1.43 h on an H100, against ~100 GPU-h per A549 condition in + production. With an organelle's three fits replaced, 8 of the 7984 pairs against other models + that the full benchmark resolves flip on the lite (2000-draw bootstrap), and 3 of 447 among the + CELL-Diff fits. Two are resolved the other way on the lite, both marginal on the full benchmark: + - mitochondria, A549 ZIKV, MorphEm median cosine, joint-trained CELL-Diff vs pix2pix3d (full z = 2.02); + - nucleus, A549 mock, DINOv3 median cosine, iPSC-trained CELL-Diff vs FNet3D-VSCyto3DAug (full z = 2.05). + + Read CELL-Diff's A549 deep-feature cosines on the lite as slightly optimistic. Measured on the mitochondria pair: + Z overlap 4 keeps it (16 evaluations), while Z overlap 3, and 18 or 24 evaluations at Z overlap 2, do not. + Three shortcuts break ordering: + - 12 or fewer evaluations on a cosine grid flip deep-feature orderings of the A549-trained nucleus fit; + - a grid with a coarse last step (Beta(0.5, 0.7), last step 0.13) loses fine texture: A549 DynaCLR KID + moves ~20 between-FOV SD. High-pass error against dopri5 ranked the three measured grids in the order of + their deep-feature shifts; whole-tile error did not; + - full-field slabs instead of 512^2 tiles break the OOD membrane fit. + + Evidence: `experiments/2026-10-01_celldiff-fast-inference/`. + +## `experiments/` — investigations, ablations and checks (gitignored) + +Every investigation, ablation, probe or planning effort gets **one directory** +`experiments/YYYY-MM-DD_/` (date = when it started), holding its plan, scripts, +outputs, logs and any derived stores, plus a `README.md` stating purpose, status, layout and +when it can go. The directory is gitignored (`applications/dynacell/.gitignore`), so nothing in +it is tracked; code that outgrows an experiment is promoted into `tools/` or `src/` with tests. +Do not leave this material in the session scratchpad or `~/.claude/plans/` (neither is +discoverable from the repo), and never at the `/hpc/mydata/alex.kalinin/` root — it belongs +to the project that produced it (see the top-level CLAUDE.md). First entry: +`2026-09-14_lite-benchmark-plan/` (DynaCell-lite research plan and phase-0 checks). + +## Repository boundary: paper artifacts do not belong here + +**This repo owns data packaging, model training and evaluation. Every paper table +and figure is produced in the dynacell repo** (`/hpc/mydata/alex.kalinin/dynacell`), +which reads the evaluation outputs this repo writes. + +The split had blurred in two directions, both since corrected: + +- `VisCy/.tmp/` accumulated 58 untracked scripts, 34 of which wrote an artifact. One + of them, `segcompare_nucleus.py`, filled the mask cache behind a **live** paper + figure, so the manuscript depended on an untracked scratch directory. It has been + copied to `dynacell/paper/scripts/` with its cache under + `$DATA_ROOT/segcompare`; the originals remain in `.tmp/`, which is now purely + exploratory. `.tmp/` is **not gitignored** — never stage it. +- `src/dynacell/reporting/` and `src/dynacell/evaluation/spectral_pcc/plot_*.py` + stay here and are correct as they are: `reporting/` is a *library* the dynacell + generators import, and the `spectral_pcc` plots are metric-validation + diagnostics, not paper figures. + +Before adding a script that emits a `.tex`, a `.pdf`, or a table, ask whether it is +producing a paper artifact. If it is, it belongs in dynacell. The generator index +lives at `dynacell/paper/scripts/CLAUDE.md`, `dynacell/paper/tables/CLAUDE.md` and +`dynacell/paper/figures/CLAUDE.md`, with retired tooling and the full `.tmp/` +classification in `dynacell/paper/archive/README.md`. diff --git a/applications/dynacell/README.md b/applications/dynacell/README.md index 0c4cd7783..87e984912 100644 --- a/applications/dynacell/README.md +++ b/applications/dynacell/README.md @@ -2,6 +2,10 @@ **An evaluation framework for dynamic 3D virtual staining of live cells.** +- 📦 **Dataset:** [DynaCell on the AWS Open Data Registry](https://registry.opendata.aws/dynacell/) +- 🤗 **Demo:** [Interactive virtual-staining Space on Hugging Face](https://huggingface.co/spaces/biohub/dynacell) +- 📓 **Notebook:** [Get to know the DynaCell dataset](examples/notebooks/get-to-know-dynacell-dataset.ipynb) + Virtual staining predicts fluorescence-like images of cell structures from label-free microscopy (brightfield, phase contrast), enabling live-cell profiling without the phototoxicity and photobleaching of direct fluorescent @@ -14,24 +18,60 @@ three linked components: Zika/Dengue perturbations), plus a reprocessed, curated subset of the Allen Institute WTC-11 hiPSC dataset for cross-cell-type and cross-microscope evaluation. -- **Baseline models** — four regression and one generative baseline, trained - under a shared protocol across nucleus, plasma membrane, endoplasmic reticulum - (ER), and mitochondria. +- **Baseline models** — four regression baselines, a deterministic 3D Pix2Pix + GAN, and CELL-Diff under conditional-mean and sampled inference, trained under + a shared protocol across nucleus, plasma membrane, endoplasmic reticulum (ER), + and mitochondria. - **Metrics** — a three-tier panel measuring pixel-level fidelity, organelle segmentation utility, and single-cell phenotypic similarity. -Across 2 cell types and microscopes, 4 organelles, and 3 perturbation states, -DynaCell exposes trade-offs that single-metric evaluation obscures: regression -baselines better predict organelle localization and are more robust to -label-free input shifts, while the generative baseline better captures +Across iPSC and A549 training/test domains, an evaluation-only HEK293T ablation, +4 organelles, and 3 perturbation states, DynaCell exposes trade-offs that +single-metric evaluation obscures. Deterministic point predictors preserve +paired spatial structure, while sampled CELL-Diff better captures population-level phenotype distributions. This directory is the DynaCell application of the [VisCy](../../README.md) monorepo. See the paper for the full benchmark description. +## Directory map + +- **[configs/](configs/README.md)** — Hydra/LightningCLI configs: reusable recipes, generic examples, and the + runnable benchmark leaves (`configs/benchmarks/virtual_staining/`). +- **[src/](src/README.md)** — the installable `dynacell` package: engines, data/manifest layer, evaluation + pipeline, reporting, preprocessing, and the bundled dataset registry. +- **[tools/](tools/README.md)** — operational scripts: leaf submission, config generation, data/artifact builders. +- **[tests/](tests/README.md)** — the pytest suite (integration-first) for the package and tools. +- **[examples/](examples/README.md)** — the dataset notebook and the Hugging Face virtual-staining demo. +- **[CLAUDE.md](./CLAUDE.md)** — conventions reference: code↔paper names, prediction/eval-dir naming, batch + semantics, eval runtime. + ## Installation -DynaCell is part of the VisCy `uv` workspace. From the repository root: +DynaCell is part of the VisCy [uv](https://docs.astral.sh/uv/) workspace and +must be installed with `uv`. Install uv first if you don't have it +(`curl -LsSf https://astral.sh/uv/install.sh | sh`), then: + +```bash +git clone --branch dynacell-models https://github.com/mehta-lab/VisCy.git +cd VisCy +uv venv -p 3.13 +source .venv/bin/activate +uv pip install -e "applications/dynacell[eval]" +``` + +The `eval` extra adds the evaluation stack (segmentation models, deep-feature +extractors, `cubic`) used for the paper's metrics; drop it if you only train +or predict. Python 3.12 or newer is required. + +Plain `pip` does not work. DynaCell depends on in-workspace packages +(`viscy-data`, `viscy-models`, `viscy-transforms`, `viscy-utils`, `dynaclr`) +that are wired through `[tool.uv.sources]` in the repository-root +`pyproject.toml`. `pip` ignores that table: it fetches older, incompatible +`viscy-*` releases from PyPI and cannot find `dynaclr` at all. + +For development (every workspace package, all extras, tests), sync the whole +workspace from the repository root instead: ```bash uv venv -p 3.13 @@ -87,18 +127,17 @@ references for localization, segmentation, and tracking. - **VSCyto3D** — UNeXt2 with a pretrained FCMAE encoder (Cytoland). - **UNetViT3D** — a hybrid CNN-Transformer adapted from the CELL-Diff backbone. -### Generative baseline (`DynacellFlowMatching`) +### Generative baselines -- **CELL-Diff** — a 2D flow-matching virtual-staining model extended to 3D +- **Pix2Pix3D** (`DynacellGAN`) — deterministic adversarial training with the + UNetViT3D generator and a multiscale 3D PatchGAN discriminator. + +- **CELL-Diff** (`DynacellFlowMatching`) — a 2D flow-matching virtual-staining model extended to 3D inputs and outputs. Samples plausible fluorescence volumes conditioned on phase; uses iterative flow-matching inpainting for large-volume inference, and a single-pass mean-prediction mode for point-estimate comparison. The flow-matching loss is computed internally — no external loss function needed. -The engine module also provides an adversarial `DynacellGAN` (pix2pix3d) sharing -the UNetViT3D generator backbone, used for controlled regression-vs-adversarial -comparison; it is not a paper baseline. - ## Evaluation metrics Three tiers, each interrogating predicted stain quality differently: @@ -106,12 +145,13 @@ Three tiers, each interrogating predicted stain quality differently: - **Pixel fidelity** — PSNR, SSIM, PCC, NRMSE, plus microscopy-aware Fourier shell correlation (FSC), MicroSSIM, and a frequency-aware Spectral PCC robust to photobleaching-driven noise in fluorescence targets. -- **Segmentation utility** — predicted and experimental volumes pass through the - Allen Institute organelle segmenters; masks compared via Dice, IoU, precision, - recall, and accuracy. -- **Phenotype similarity** — per-cell embeddings from CellProfiler, DINOv3, and - DynaCLR; median cosine similarity between matched cells plus FID and KID - between pooled predicted and experimental distributions. +- **Segmentation utility** — Cellpose v4 cpdino instances for nucleus and + membrane, and Allen Institute semantic segmenters for ER and mitochondria; + masks are compared with overlap and instance-detection metrics. +- **Phenotype similarity** — a 22-feature handcrafted GLCM+ space and learned + DINOv3, DynaCLR, CELL-DINO, and MorphEm embeddings; median cosine similarity + between matched cells plus FID and KID between pooled predicted and + experimental distributions. ## Config structure @@ -179,3 +219,32 @@ a bare invocation writes **and** submits. Institute Terms of Use. - **Demo** — a small reviewer sample is at [dynacell_a549_demo.zip](https://dynacell.s3.us-west-2.amazonaws.com/v1/demo/dynacell_a549_demo.zip). +- **Trained checkpoints** — one per (training set, organelle, model) for all six + baselines, at `s3://dynacell/v1/models/`. The + [models README](https://dynacell.s3.us-west-2.amazonaws.com/v1/models/README.md) + describes the layout, the `checkpoints.csv` manifest, and how to load a checkpoint. + Download one model with + `aws s3 cp --no-sign-request --recursive s3://dynacell/v1/models/ipsc/nucleus/vscyto3d/ ./vscyto3d_nucleus/`. + +## Citation + +If you use DynaCell (code, data, or trained checkpoints), please cite +([CITATION.cff](CITATION.cff)): + +```bibtex +@inproceedings{kalinin2026dynacell, + title = {{DynaCell}: An Evaluation Framework for Dynamic {3D} Virtual Staining of Live Cells}, + author = {Kalinin, Alexandr A. and Zheng, Dihan and Theodoro, Taylla Milena and + Ivanov, Ivan and Hirata-Miyasaki, Eduardo and Lee, See-Chi and Liu, Aofei and + Varra, Sricharan Reddy and Chandler, Talon and Pradeep, Soorya and Liu, Chad and + Leonetti, Manuel D. and Arias, Carolina and Huang, Bo and Mehta, Shalin B.}, + booktitle = {Advances in Neural Information Processing Systems (NeurIPS 2026), Evaluations and Datasets Track}, + year = {2026} +} +``` + +## Navigation + +- Up: [VisCy monorepo](../../README.md) +- Subdirectories: [configs/](configs/README.md) · [src/](src/README.md) · [tools/](tools/README.md) · + [tests/](tests/README.md) · [examples/](examples/README.md) diff --git a/applications/dynacell/docs/evaluating-external-checkpoints.md b/applications/dynacell/docs/evaluating-external-checkpoints.md new file mode 100644 index 000000000..bff4cd572 --- /dev/null +++ b/applications/dynacell/docs/evaluating-external-checkpoints.md @@ -0,0 +1,496 @@ +# Evaluating an external model on the DynaCell benchmark + +How to score a **third-party model** (yours or a collaborator's) on the two DynaCell +virtual-staining test sets (iPSC confocal + A549 mantis) and get the same metrics the +paper matrix reports — pixel, feature (FID/KID/precision-recall + deep embeddings), and +optional instance-AP. + +**Scope of this guide:** the model is a **PyTorch** `nn.Module` (not TF/JAX), likely +**not** a Lightning module, and you are **not** adding new data — you predict on the +existing DynaCell test stores and run metrics. If your model can't be expressed as a +torch module on `(B, 1, Z, Y, X)` grids, jump to [Appendix B](#appendix-b--pure-torch-no-lightning-at-all). +To **fine-tune on DynaCell train data first**, see [§8](#8-fine-tuning-on-dynacell-train-data). + +--- + +## 0. Mental model: two steps, two contracts + +The eval pipeline **scores prediction zarrs — it never runs your model.** So every route +is two steps: + +``` +your .ckpt ──(predict)──▶ prediction.zarr ──(dynacell evaluate)──▶ metrics +``` + +You only ever have to satisfy two contracts: + +1. **Prediction-zarr contract** (what `dynacell evaluate` reads): an HCS OME-Zarr whose + position names match the GT store, with a channel named `_prediction`. +2. **Predict-writer contract** (only if you reuse `HCSPredictionWriter`, recommended): + your `predict_step` returns a `(B, C, Z, Y, X)` tensor; the DataModule supplies the + `batch["index"]` FOV triplet. Reusing the writer guarantees contract #1 for free + (correct position names, channel naming, pixel-size, and 2.5D Z-blending). + +GT path, cell-segmentation path, GT channel name, and pixel spacing are **all supplied +automatically** by the dataset manifest — you never hand-copy them (see Step 2). + +--- + +## 1. Prerequisites + +### Recreate the environment + +VisCy is a `uv` workspace. Build the venv from the repo root with **all workspace +packages and extras** — that pulls the dynacell `eval` + `eval_gpu` extras (cellpose≥4.2 with dinov3 for cpdino, +`cubic` from git, `torch-fidelity` w/ MIND, and the CUDA-13 +`cupy-cuda13x`/`cucim-cu13` GPU stack that matches torch 2.12 cu13): + +```sh +git clone https://github.com/mehta-lab/VisCy.git && cd VisCy +git checkout dynacell-paths-module # branch carrying the dynacell eval pipeline +uv venv -p 3.13 # 3.11 / 3.12 also fine +uv sync --all-packages --all-extras # local install of all workspace packages + extras +``` + +Run **everything below via `uv run …`** so it uses this `.venv`. `cubic` (GPU) is a hard +dep of the eval pipeline — no CPU fallback. + +### Other prerequisites + +- **DINOv3 is a gated HF model.** Feature metrics load it from the team HF cache + (`HF_HUB_CACHE` defaults to the shared project cache; override with + `DYNACELL_SHARED_HF_CACHE`). You need a HF token with access, or set + `compute_feature_metrics=false` for pixel-only. +- **Instance-AP (`compute_instance_ap=true`) with the `cpdino` backend** runs in the same + `.venv`: the `eval` extra pins cellpose >= 4.2, which provides Cellpose-DINO. +- GT feature caches and cell-segmentation stores for **both** test sets are already + warmed and the manifests are repointed to them — nothing to precompute. + +--- + +## 2. The two test sets (all values come from the manifest) + +You never set these by hand; they are here for reference. Eval resolves them from the +manifest via the `dataset_ref`. + +### iPSC confocal — `dataset: aics-hipsc`, spacing `[0.290, 0.108, 0.108]` (z,y,x µm) + +| organelle | `dataset_ref.target` | GT channel | test store | +|---|---|---|---| +| ER | `sec61b` | `Structure` | `ipsc/dataset_v4/test_cropped/SEC61B.zarr` | +| Mito | `tomm20` | `Structure` | `ipsc/dataset_v4/test_cropped/TOMM20.zarr` | +| Nucleus | `nucleus` | `Nuclei` | `ipsc/dataset_v4/test_cropped/cell.zarr` | +| Membrane | `membrane` | `Membrane` | `ipsc/dataset_v4/test_cropped/cell.zarr` | + +### A549 mantis — `dataset: a549-mantis--`, spacing `[0.174, 0.1494, 0.1494]` + +12 cells = 4 organelles × `` ∈ {`mock`, `denv`, `zikv`}. Test stores at +`a549/mantis/test/` (regenerated, 640×960 raw). **Note the key asymmetry**: A549 +nucleus/membrane are keyed by **gene** (`h2b`/`caax`), not by organelle. + +| organelle | `dataset_ref.target` | GT channel | test store (`_`) | +|---|---|---|---| +| ER | `sec61b` | `Structure` | `SEC61B_.zarr` | +| Mito | `tomm20` | `Structure` | `TOMM20_.zarr` | +| Nucleus | `h2b` | `Nuclei` | `dual_nucl_memb_.zarr` | +| Membrane | `caax` | `Membrane` | `dual_nucl_memb_.zarr` | + +The `(dataset, target)` pairs above are the single source of truth used by **both** the +predict driver (via the resolver) and the eval driver (via `dataset_ref`). + +--- + +## 3. Step 1 — Predict (thin Lightning shim, ~15 lines) + +Wrap your torch module in a minimal `LightningModule` so you inherit `HCSDataModule` +(reads Phase3D, tiles, normalizes, emits the FOV `index`) and `HCSPredictionWriter` +(writes the contract-correct zarr). **Your model does not need to be Lightning** — the +shim only wraps its `forward`. + +```python +# predict_external.py — run: uv run python predict_external.py +from pathlib import Path + +import torch +from lightning.pytorch import LightningModule +from viscy_data.hcs import HCSDataModule +from viscy_transforms import NormalizeSampled +from viscy_utils.callbacks import HCSPredictionWriter +from viscy_utils.trainer import VisCyTrainer + +from dynacell.data.resolver import dataset_ref_from_dict, resolve_dataset_ref + +# ─── EDIT THESE FOUR THINGS ──────────────────────────────────────────────── +OUT_ROOT = Path("/hpc/projects/.../my_model/predictions") # your own dir, NOT the campaign tree +MODEL_ORGANELLES = ["nucleus", "membrane"] # which organelle(s) your model predicts +Z_WINDOW = 15 # axial context your model expects (1 for 2D) +FULL_IMAGE = True # False -> tile fixed-size nets (see note) + +def load_model() -> torch.nn.Module: + """Load YOUR torch model with weights, in eval mode.""" + model = MyNet(...) # <- your architecture + model.load_state_dict(torch.load("/path/to/your.ckpt")["state_dict"]) + return model.eval() +# ─────────────────────────────────────────────────────────────────────────── + +class TorchShim(LightningModule): + """Adapts a plain torch nn.Module to the predict-writer contract.""" + def __init__(self, model: torch.nn.Module): + super().__init__() + self.model = model + + @torch.no_grad() + def predict_step(self, batch, batch_idx, dataloader_idx=0): + source = batch["source"] # (B, 1, Z, Y, X) + if FULL_IMAGE: + pred = self.model(source) # FCN handles the full FOV + else: + # fixed-size net: overlap-averaging sliding window over 512² tiles + from dynacell.engine import _sliding_window_inference + pred = _sliding_window_inference(self.model, source, (Z_WINDOW, 512, 512), overlap_size=32) + return pred # MUST be (B, C, Z, Y, X), C == #targets + +# organelle -> the (dataset, target) cells to predict on both test sets +CELLS = { + "er": [("aics-hipsc", "sec61b")] + [(f"a549-mantis-sec61b-{c}", "sec61b") for c in ("mock", "denv", "zikv")], + "mito": [("aics-hipsc", "tomm20")] + [(f"a549-mantis-tomm20-{c}", "tomm20") for c in ("mock", "denv", "zikv")], + "nucleus": [("aics-hipsc", "nucleus")] + [(f"a549-mantis-h2b-{c}", "h2b") for c in ("mock", "denv", "zikv")], + "membrane": [("aics-hipsc", "membrane")] + [(f"a549-mantis-caax-{c}", "caax") for c in ("mock", "denv", "zikv")], +} + +shim = TorchShim(load_model()) +for organelle in MODEL_ORGANELLES: + for dataset, target in CELLS[organelle]: + r = resolve_dataset_ref(dataset_ref_from_dict({"dataset": dataset, "target": target})) + out = OUT_ROOT / f"{dataset}__{target}.zarr" # one pred store per cell + dm = HCSDataModule( + data_path=str(r.data_path_test), # the GT test store (has Phase3D) + source_channel=r.source_channel, # "Phase3D" + target_channel=[r.target_channel], # "Structure"/"Nuclei"/"Membrane" -> "_prediction" + z_window_size=Z_WINDOW, + batch_size=1, + num_workers=8, + normalizations=[NormalizeSampled([r.source_channel], level="fov_statistics", + subtrahend="mean", divisor="std")], # ← must match YOUR training! + ) + trainer = VisCyTrainer(callbacks=[HCSPredictionWriter(str(out))]) + trainer.predict(model=shim, datamodule=dm, return_predictions=False) + print(f"wrote {out} (channel {r.target_channel}_prediction)") +``` + +**Correctness knobs you MUST get right:** + +- **Normalization** — the single biggest footgun. `NormalizeSampled(fov_statistics, …)` + reads precomputed per-FOV stats already stored in the test zarrs. **Set `subtrahend`/ + `divisor` (and the transform itself) to exactly what your model trained with.** If your + model expects a different normalization, replace this transform. Wrong normalization + silently produces garbage metrics. +- **`z_window_size`** — `1` for a 2D model, `k` for 2.5D, your model's full axial input + for 3D. Determines the Z extent fed per sample. +- **`FULL_IMAGE`** — the A549 test FOVs are **640×960**. If your net is fully + convolutional, `True` runs the whole FOV. If it's fixed-size (e.g. 512²), set `False` + to tile (as the campaign's ViT models do); iPSC (512²) is a single tile either way. +- **Output channel name** is `_prediction`, which is exactly what eval's + `pred_channel_name` defaults to — leave `target_channel` matching the GT channel. +- **Positions align automatically** because you predict *from* the GT store, so the + writer creates the same FOV names eval matches against. + +> Proven `data:` params for the standard architectures live in +> `configs/benchmarks/virtual_staining/_internal/shared/model/model_overlays/*_predict.yml` +> — copy the `z_window_size` / `normalizations` / `predict_method` from the overlay +> closest to your model's dimensionality if unsure. + +For SLURM instead of a local GPU, wrap the same logic behind +`tools/submit_benchmark_job.py` with your own predict leaf; for a one-off, the script +above on an interactive GPU is simplest. + +### If your model is generative (flow-matching / diffusion) + +A flow-matching fine-tune (e.g. on an EvolutionaryScale **Katamari** backbone) is **not a +single-forward regressor** — it produces a sample by integrating an ODE from noise, +conditioned on the phase input. Two consequences: + +1. **`predict_step` runs the sampler, not `self.model(source)`.** Return the final sample + as `(B, C, Z, Y, X)`: + + ```python + @torch.no_grad() + def predict_step(self, batch, batch_idx, dataloader_idx=0): + source = batch["source"] # (B, 1, Z, Y, X) conditioning + pred = self.model.generate(source, num_steps=100) # your ODE sampler → (B, C, Z, Y, X) + return pred + ``` + + The repo already ships this pattern: **`DynacellFlowMatching`** + (`applications/dynacell/src/dynacell/engine.py:480`, wrapping `CELLDiff3DVS` in + `celldiff_wrapper.py`) dispatches `predict_step` to + `model.generate` / `generate_sliding_window` / `generate_iterative`. Mirror it — your + Katamari model just needs to expose a `generate(cond, num_steps)`-style sampler, or you + inline your sampling loop in `predict_step`. + +2. **Everything downstream is identical.** The benchmark **already scores CellDiff, a + flow-matching model**, on the same metrics — so once you write a conforming + `prediction.zarr`, **Step 2 (eval) is unchanged.** No pipeline edits. + +**Latent / conditioned / non-Lightning samplers → use [Appendix B](#appendix-b--pure-torch-no-lightning-at-all), not the shim.** +If the model isn't a plain phase→image module — it samples in a latent space, conditions +on more than the phase (an identity/target-channel embedding), decodes embeddings to +pixels, or runs under a non-Lightning trainer — don't force it through `HCSDataModule` / +`predict_step`. Run its **native sampler in its own environment** to produce per-FOV pixel +images, then write a conforming `prediction.zarr` (Appendix B) and evaluate. Keep these +aligned so the numbers match the matrix: + +- **Predict the exact DynaCell test FOVs and preserve position names** — the pred store's + `row/col/fov` must equal the GT store's (eval matches by name). +- **Map each organelle to its conditioning and output channel** — condition on the target + identity for that organelle and write the sample as its GT channel + (`Nuclei`/`Membrane`/`Structure`) + `_prediction`. For an **identity-conditioned** model, + confirm the DynaCell target proteins (H2B→nucleus, CAAX→membrane, SEC61B→ER, + TOMM20→mito) are in the model's conditioning vocabulary — otherwise the run is *zero-shot* + on those identities, a valid but distinct claim to state explicitly. +- **A 2D model must write Z=48, not Z=1** (verified against the eval code). The pipeline + assumes `pred.Z == GT.Z == seg.Z == 48` — the in-focus plane is computed on the GT and + applied to the prediction — so a `Z=1` store raises `ValueError` in *every* metric family + (`pipeline.py` pixel loop, CP `regionprops`, `focus.py:slab_mip` empty-slice reduction). + **Replicate your single predicted plane across all 48 Z.** Then the focus-reduced metrics + — **deep-feature FID/KID/precision-recall and instance-AP** — recover exactly your plane + and are correct (all planes identical → the focus-plane MIP equals your prediction). ⚠️ + But **pixel metrics (SSIM/PCC/FSC) and CP-regionprops stay full-3D volumetric** — they + never consult the focus plane — so a flat-replicated pred scored against the real 48-plane + GT gives *unfair* per-pixel/morphometry numbers. For comparable pixel/CP numbers on a 2D + model you must either **predict per-Z to fill a true volume** (≈48× the sampling cost) or + **add focus-plane reduction to the pixel/CP path** (a small pipeline change). This is the + one place a 2D generative model needs a real decision, not just a writer tweak. +- **Seed the sampler** and record `num_steps` / guidance scale for reproducibility. + +**Generative-specific gotchas:** + +- **Seed the sampler** for reproducibility (`torch.manual_seed(...)`) and record + `num_steps` — it trades quality vs wall-time. +- **Sampling is slow** (CellDiff runs ~hours/FOV at 100 steps). Run predict on SLURM via + `tools/submit_benchmark_job.py`, and use `--resume-predict` if a wall-time kill leaves a + partially-written store. Resume relies on the writer's completion markers (which record + the checkpoint and a hash of the prediction settings), so a store written before markers + existed, or with other weights or settings, is refused: predict it into a new output + store instead. +- **640×960 A549 exceeds a single flow-matching patch** — use an overlap-anchored tiler + (`generate_iterative`), not one full-FOV pass (same constraint CellDiff/ViT hit; iPSC + 512² is a single patch, so `FULL_IMAGE`-equivalent there). +- **Reading the metrics:** FID/KID/precision-recall (distribution-level) are the + meaningful generative-quality metrics; per-pixel SSIM/PCC penalize a stochastic sample's + non-registration. The benchmark reports all and scores CellDiff on all, so your numbers + stay directly comparable to the matrix. + +--- + +## 4. Step 2 — Evaluate (manifest-driven, one call per cell) + +Point eval at your prediction zarr; the `target=` + `predict_set=` **groups** splice +`gt_path`, `cell_segmentation_path`, `gt_channel_name`, `pred_channel_name`, and +`pixel_metrics.spacing` from the manifest. You supply only `io.pred_path` and +`save.save_dir`. + +**iPSC, e.g. nucleus:** +```sh +uv run dynacell evaluate \ + target=nucleus predict_set=ipsc_confocal \ + io.pred_path=/hpc/.../my_model/predictions/aics-hipsc__nucleus.zarr \ + compute_feature_metrics=true \ + save.save_dir=/hpc/.../my_model/eval/ipsc_nucleus +``` + +**A549 ER, mock:** +```sh +uv run dynacell evaluate \ + target=er_sec61b predict_set=a549_mantis_sec61b_mock \ + io.pred_path=/hpc/.../my_model/predictions/a549-mantis-sec61b-mock__sec61b.zarr \ + compute_feature_metrics=true \ + save.save_dir=/hpc/.../my_model/eval/a549_er_mock +``` + +**A549 nucleus/membrane need the gene-key override** (the target group defaults to the +organelle name, but the A549 manifest keys by gene): +```sh +uv run dynacell evaluate \ + target=nucleus predict_set=a549_mantis_h2b_mock \ + benchmark.dataset_ref.target=h2b \ + io.pred_path=/hpc/.../my_model/predictions/a549-mantis-h2b-mock__h2b.zarr \ + compute_feature_metrics=true \ + save.save_dir=/hpc/.../my_model/eval/a549_nucleus_mock +``` + +**Group name reference:** + +| organelle | `target=` | iPSC `predict_set=` | A549 `predict_set=` (`_`) | A549 extra override | +|---|---|---|---|---| +| ER | `er_sec61b` | `ipsc_confocal` | `a549_mantis_sec61b_` | — | +| Mito | `mito_tomm20` | `ipsc_confocal` | `a549_mantis_tomm20_` | — | +| Nucleus | `nucleus` | `ipsc_confocal` | `a549_mantis_h2b_` | `benchmark.dataset_ref.target=h2b` | +| Membrane | `membrane` | `ipsc_confocal` | `a549_mantis_caax_` | `benchmark.dataset_ref.target=caax` | + +A tiny bash loop over your `MODEL_ORGANELLES` × these rows evaluates every cell. +Do **not** use `dynacell evaluate-grouped` / the grouped-eval generators for this — those +walk the campaign's on-disk prediction tree (and the walker fix isn't on `main` yet). One +`dynacell evaluate` call per cell is the robust path for an external model. + +--- + +## 5. What each metric family needs + +| Family | Extra input | Flag | Env | +|---|---|---|---| +| **Pixel** (SSIM, PCC, spectral, FSC…) | pred + GT + spacing (auto) | default | repo `.venv` | +| **Feature** (FID/KID/precision-recall + DINOv3/DynaCLR/CELL-DINO/MorphEm embeddings) | labeled cell-seg store (auto from manifest) | `compute_feature_metrics=true` | repo `.venv` + HF token for DINOv3 | +| **Instance-AP** (whole-cell / nucleus mAP) | runs its own segmentation | `compute_instance_ap=true` + `segmentation.backend=cpdino` | repo `.venv` | + +Notes: +- Feature crops come from the **fixed** `cell_segmentation_path`, so they're independent + of the instance-AP segmentation — the two segmentations are separate. +- Focus-2D is **on by default** (`slice_selection=focus`, `feature_metrics.focus_slab`) + and needs a `Phase3D` channel for the focus plane — present in every test store, so + leave it on. Disable those knobs only if you point at a store without phase. +- No cell-seg store and don't want features? `compute_feature_metrics=false` gives + pixel + binary-mask metrics only. + +--- + +## 6. Outputs + +Each `dynacell evaluate` writes to its `save.save_dir`: per-FOV and aggregate metric CSVs, +plus (when `compute_feature_metrics=true`) the deep-embedding NPZ files. Collect the +`save_dir`s across cells to assemble your comparison table. + +--- + +## 7. Working alongside the active A549 campaign + +The A549 regen→retrain→re-eval campaign is mid-flight (re-predict draining, re-eval +pending), so: + +- **Write your predictions and evals to your own directory** — never into + `a549/predictions/`, `a549/evaluations*_with_embeddings/`, or the per-train-dir + prediction tree. Standalone `io.pred_path` + `save.save_dir` keep you fully insulated. +- **Both test sets are safe to read now**: the manifests are repointed to the + regenerated 640×960 raw A549 stores + combined `dual_nucl_memb` store, and GT + caches/seg stores are warmed. iPSC has been stable throughout. +- The pred-side eval cache is geometry-blind — since you write to fresh `io.pred_path`s + under your own dir, you won't hit stale-cache aliasing. + +--- + +## 8. Fine-tuning on DynaCell train data + +To fine-tune your model on DynaCell before benchmarking, use the **train** stores. They are +**physically separate** from the test stores (§2) — built from a fixed split by the +assembler — so training on a full train store never touches an eval FOV. **Never point +training at a `test` / `test_cropped` store**, or the benchmark numbers are invalid. + +### Train stores + +Resolve them from the same manifest resolver as predict/eval — `data_path_train` instead of +`data_path_test`: + +```python +from dynacell.data.resolver import dataset_ref_from_dict, resolve_dataset_ref +r = resolve_dataset_ref(dataset_ref_from_dict({"dataset": "aics-hipsc", "target": "nucleus"})) +r.data_path_train # train store (disjoint from r.data_path_test) +r.source_channel # "Phase3D" +r.target_channel # "Nuclei" / "Membrane" / "Structure" — paired GT in the SAME store +``` + +| test set | organelle | `(dataset, target)` | train store | +|---|---|---|---| +| iPSC | ER / Mito / Nuc / Memb | `(aics-hipsc, {sec61b,tomm20,nucleus,membrane})` | `ipsc/dataset_v4/train/{SEC61B,TOMM20,cell,cell}.zarr` | +| A549 | ER | `(a549-mantis-sec61b-, sec61b)` | `a549/mantis/train/SEC61B_all.zarr` | +| A549 | Mito | `(a549-mantis-tomm20-, tomm20)` | `a549/mantis/train/TOMM20_all.zarr` | +| A549 | Nuc / Memb | `(a549-mantis-{h2b,caax}-, {h2b,caax})` | `a549/mantis/train/dual_nucl_memb_all.zarr` | + +Each store holds **paired** `(Phase3D source, target fluorescence)` per FOV — the training +signal. Notes: + +- **A549 train is condition-pooled** — one `_all.zarr` per target combines mock + ZIKV + + DENV train FOVs, with the condition dropped from the FOV name (`fov0000…`). Any A549 + `` in the ref resolves to the same pooled train store; test stays per-condition. +- **iPSC** ships a dedicated `train/` vs `test_cropped/` split — the whole `train/` store + *is* the train split. +- **Geometry differs across sets** — A549 640×960 @ 0.174/0.1494 µm, iPSC 512² @ + 0.290/0.108 µm. If you pool both, resample/normalize to a common convention (DynaCell + models train per-set; matching the target set's voxel size is safest). +- **The split is metadata-fixed** — each manifest target carries `splits/<...>.yaml` + (`dynacell.data.manifests.load_splits()` → `.train`/`.test`); the assembler already + applied it to separate the stores, so you don't filter FOVs yourself — that file is just + the record of what is train vs test. + +### Loading for training + +- **Lightning trainer**: `HCSDataModule(data_path=r.data_path_train, + source_channel=r.source_channel, target_channel=[r.target_channel], …)` in fit mode + yields paired `source`/`target` batches (what the DynaCell models use). +- **Non-Lightning trainer** (e.g. a Zarr-based pipeline): open `r.data_path_train` with + `iohub.open_ome_zarr` and read the `source_channel` + `target_channel` arrays per + position directly. Apply your model's own normalization — the stores also carry + `viscy preprocess` fov-statistics in `.zattrs` if you want to match DynaCell's. +- **Identity-conditioned models**: the `target_channel` per store *is* the protein you're + learning to stain — H2B (nucleus), CAAX (membrane), SEC61B (ER), TOMM20 (mito). Use these + as the conditioning identities so fine-tuning and eval (§3) agree. + +--- + +## Appendix A — reusing an existing architecture + +If your checkpoint *is* one of the DynaCell engine architectures +(`DynacellUNet`/`DynacellGAN`/celldiff), skip the shim: author a predict leaf +(`base:` the matching `model_overlays/_predict.yml`), set +`model.init_args.ckpt_path`, and run `tools/submit_benchmark_job.py --ckpt best`. +Then evaluate as in Step 2. + +## Appendix B — pure torch, no Lightning at all + +If your model can't fit `HCSDataModule`'s I/O (different input channels, an external +sampler, non-grid), skip the whole predict stack and satisfy only the prediction-zarr +contract directly with iohub: + +```python +from iohub import open_ome_zarr +from dynacell.data.resolver import dataset_ref_from_dict, resolve_dataset_ref + +r = resolve_dataset_ref(dataset_ref_from_dict({"dataset": "aics-hipsc", "target": "nucleus"})) +with open_ome_zarr(str(r.data_path_test), mode="r") as gt, \ + open_ome_zarr("pred.zarr", layout="hcs", mode="w-", + channel_names=[f"{r.target_channel}_prediction"]) as out: + src_idx = gt.channel_names.index(r.source_channel) # Phase3D + for pos_name, gt_pos in gt.positions(): # e.g. "0/0/fov0000" + row, col, fov = pos_name.split("/") + phase = gt_pos["0"][:, src_idx:src_idx + 1] # (T, 1, Z, Y, X) + pred_tczyx = run_your_model(phase) # (T, 1, Z, Y, X), Z/Y/X == GT + out.create_position(row, col, fov).create_image("0", pred_tczyx) +``` + +Then run Step 2 unchanged — position names mirror the GT store, and the channel is named +`_prediction`, so eval matches by name. (Set `io.pred_channel_name` explicitly if +you name it anything else.) + +> **2D model?** `pred_tczyx` must be `Z=48` (match the GT), not `Z=1` — a single-Z store +> fails every metric. Replicate your predicted plane across Z (`np.broadcast_to(plane, +> (T, 1, 48, Y, X))`). Feature + instance-AP metrics then recover your plane correctly; +> pixel/CP metrics stay volumetric — see the Z-handling bullet in §3. +``` + +--- + +## Key source references + +- Prediction-writer contract: `packages/viscy-utils/src/viscy_utils/callbacks/prediction_writer.py` + (`on_predict_start` names `_prediction`; `write_sample` maps the `batch["index"]` FOV triplet). +- `predict_step` shape contract: `applications/dynacell/src/dynacell/engine.py:402` + (`DynacellUNet.predict_step` — pad → forward → center-crop; `_sliding_window_inference` helper). +- Manifest → eval splice: `applications/dynacell/src/dynacell/evaluation/_ref_hook.py` + (`_RESOLVED_FIELDS`: `io.gt_path`, `io.cell_segmentation_path`, `io.gt_channel_name`, + `io.gt_cache_dir`, `pred_channel_name`, `pixel_metrics.spacing`). +- Resolver API: `applications/dynacell/src/dynacell/data/resolver.py` + (`resolve_dataset_ref`, `dataset_ref_from_dict`, `ResolvedDataset`). +- Eval config surface: `applications/dynacell/src/dynacell/evaluation/_configs/eval.yaml` + (`io.*`, `segmentation.*`, `compute_feature_metrics`, `compute_instance_ap`, `focus.*`). +- Test-set manifests: `applications/dynacell/src/dynacell/_manifests/{aics-hipsc,a549-mantis-*}/manifest.yaml`. +- Target/predict-set groups: `configs/benchmarks/virtual_staining/_internal/shared/eval/target/`, + `src/dynacell/evaluation/_configs/predict_set/`. diff --git a/applications/dynacell/examples/README.md b/applications/dynacell/examples/README.md new file mode 100644 index 000000000..8df7308fa --- /dev/null +++ b/applications/dynacell/examples/README.md @@ -0,0 +1,20 @@ +# examples + +Runnable, user-facing entry points into DynaCell: an exploratory notebook and the interactive Hugging Face +Space. Generic fit/predict config stubs live separately under [`../configs/examples/`](../configs/README.md). + +## Contents + +- **notebooks/** — `get-to-know-dynacell-dataset.ipynb`, a guided tour of the DynaCell OME-Zarr dataset + (linked from the top-level [README](../README.md)). +- **hf_demo/** — the DynaCell virtual-staining Hugging Face Space (Gradio, ZeroGPU) and its deploy tooling: + - `hf_space/` — the deployed app (`app.py`, `predict_runner.py`, `config_templates/`, `requirements.txt`) and + its own [Space README](hf_demo/hf_space/README.md) (HF card front-matter). + - `build_demo_data.py`, `upload_demo_data.py` — build the demo-data zips from the release test split / push them to HF. + - `upload_checkpoints.py`, `upload_hf_space.py` — push checkpoints / the Space to HF. + - `cards/` — HF repo cards for the checkpoints and demo-data repos. + - `AGENT.md` — how the demo is structured and deployed (see also the `hf-dynacell` skill). + +## Navigation + +- Up: [applications/dynacell](../README.md) diff --git a/applications/dynacell/examples/hf_demo/AGENT.md b/applications/dynacell/examples/hf_demo/AGENT.md index d3bca74e1..dc8ea2f05 100644 --- a/applications/dynacell/examples/hf_demo/AGENT.md +++ b/applications/dynacell/examples/hf_demo/AGENT.md @@ -12,7 +12,9 @@ Three stacked sections, each with its own Timepoint + Z-slice sliders: noise → prediction, with that step's Spectral PCC. Inference runs on the single selected timepoint only. Data comes from the demo -dataset repo (no user upload). +dataset repo (no user upload): one held-out A549 test FOV per marker, cropped from +the release by `build_demo_data.py` (5 timepoints, 32 Z, 512x512). Checkpoints are +the released A549-trained models (`s3://dynacell/v1/models/a549/`). ## Layout @@ -25,9 +27,10 @@ hf_demo/ README.md # Space card config_templates/ # per-model predict YAMLs (celldiff/fnet3d/vscyto3d) cards/ # README cards for the model + dataset repos - upload_checkpoints.py # publish checkpoints (run on HPC) + build_demo_data.py # build the demo-data zips from the release (run on HPC) + upload_demo_data.py # publish the demo-data zips + card + upload_checkpoints.py # publish the release checkpoints (run on HPC) upload_hf_space.py # push hf_space/ to the Space - mirror_to_biohub.py # one-time mirror from dihan-zheng/* ``` Hosting, access model, ZeroGPU configuration, and the deploy/smoke-test diff --git a/applications/dynacell/examples/hf_demo/build_demo_data.py b/applications/dynacell/examples/hf_demo/build_demo_data.py new file mode 100644 index 000000000..1e05e6cc6 --- /dev/null +++ b/applications/dynacell/examples/hf_demo/build_demo_data.py @@ -0,0 +1,95 @@ +"""Build the demo-data zips for biohub/dynacell-demo-data from the public release. + +One held-out A549 test FOV per marker (``fov0006``, the FOV of the release reviewer +demo), mock condition, read from the release's ``data/biohub-a549/test/{MARKER}_mock.ozx``: + +- T: 5 of the 10 timepoints (every other one, 5-21 hpi) +- C: Phase3D, Brightfield, target fluorescence (index 2, as the Space expects) +- Z: the central 32 of 48 slices, the Z window FNet3D was trained on +- YX: the central 512 x 512 of the 640 x 960 FOV + +Each store is written as OME-Zarr v0.5 and zipped (stored, chunks are already +compressed) to ``{out_dir}/{MARKER}_mock.zarr.zip`` with ``{MARKER}_mock.zarr/`` at the +zip root. Run on HPC: + + uv run python applications/dynacell/examples/hf_demo/build_demo_data.py OUT_DIR +""" + +import argparse +import shutil +import zipfile +from pathlib import Path + +import numpy as np +from iohub import open_ome_zarr +from iohub.ngff.models import TransformationMeta + +RELEASE_TEST = Path("/hpc/projects/virtual_staining/dynacell_v1/data/biohub-a549/test") +MARKERS = ("CAAX", "H2B", "SEC61B", "TOMM20") +FOV = "0/0/fov0006" +TIMEPOINTS = [0, 2, 4, 6, 8] +Z_SIZE = 32 +YX_SIZE = 512 + + +def build_store(marker: str, out_dir: Path) -> Path: + """Crop one marker's test FOV into ``{marker}_mock.zarr``; return the store path.""" + src_path = RELEASE_TEST / f"{marker}_mock.ozx" + with open_ome_zarr(src_path, mode="r") as plate: + src = plate[FOV] + _, _, n_z, n_y, n_x = src.data.shape + z0, y0, x0 = (n_z - Z_SIZE) // 2, (n_y - YX_SIZE) // 2, (n_x - YX_SIZE) // 2 + data = np.stack([src.data[t, :, z0 : z0 + Z_SIZE, y0 : y0 + YX_SIZE, x0 : x0 + YX_SIZE] for t in TIMEPOINTS]) + channel_names = list(src.channel_names) + scale = src.scale + hpi = [src.zattrs["hpi_values"][t] for t in TIMEPOINTS] + # Released ER/mito targets are raw camera counts; deconvolved ones go negative. + neg = float((data[:, 2] < 0).mean()) + if neg > 0: + raise ValueError(f"{marker}: {neg:.4%} negative target pixels, expected raw (0%)") + + store = out_dir / f"{marker}_mock.zarr" + with open_ome_zarr(store, layout="hcs", mode="w-", channel_names=channel_names, version="0.5") as out: + pos = out.create_position("0", "0", "fov0006") + pos.create_image( + "0", + data, + chunks=(1, 1, Z_SIZE, YX_SIZE, YX_SIZE), + transform=[TransformationMeta(type="scale", scale=scale)], + ) + pos.zattrs["dynacell_demo"] = { + "source": f"s3://dynacell/v1/data/biohub-a549/test/{marker}_mock.ozx", + "position": FOV, + "timepoints": TIMEPOINTS, + "hpi_values": hpi, + "zyx_offset": [z0, y0, x0], + "zyx_size": [Z_SIZE, YX_SIZE, YX_SIZE], + } + print(f"{marker}: {data.shape} {data.dtype}, zyx offset {(z0, y0, x0)}, channels {channel_names}") + return store + + +def zip_store(store: Path) -> Path: + """Zip ``store`` (stored) with the store directory at the zip root.""" + zip_path = store.with_name(store.name + ".zip") + with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_STORED) as zf: + for f in sorted(store.rglob("*")): + if f.is_file(): + zf.write(f, f.relative_to(store.parent)) + return zip_path + + +def main() -> None: + ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + ap.add_argument("out_dir", type=Path) + args = ap.parse_args() + args.out_dir.mkdir(parents=True, exist_ok=True) + for marker in MARKERS: + store = build_store(marker, args.out_dir) + zip_path = zip_store(store) + shutil.rmtree(store) + print(f" -> {zip_path} ({zip_path.stat().st_size / 1e6:.0f} MB)") + + +if __name__ == "__main__": + main() diff --git a/applications/dynacell/examples/hf_demo/build_demo_data_test.py b/applications/dynacell/examples/hf_demo/build_demo_data_test.py new file mode 100644 index 000000000..322f38be7 --- /dev/null +++ b/applications/dynacell/examples/hf_demo/build_demo_data_test.py @@ -0,0 +1,96 @@ +r"""Integration tests for ``build_demo_data.py``. + +Each test packs a tiny synthetic release-style ``{marker}_mock.ozx`` whose voxel values +are their own flat index, then runs the real builder with only the source dir and crop +sizes patched down. Because the crop is a pure copy, assertions are exact equality. + +Run:: + + uv run --no-sync pytest applications/dynacell/examples/hf_demo/build_demo_data_test.py -q +""" + +import sys +import zipfile +from pathlib import Path + +import build_demo_data +import numpy as np +import pytest +from iohub.core.ozx import pack_ozx +from iohub.ngff import TransformationMeta, open_ome_zarr + +_SHAPE = (10, 3, 12, 20, 24) +_HPI = [5.0 + 2 * t for t in range(_SHAPE[0])] + + +def _write_release_ozx(src_dir: Path, marker: str, target: str, negative: bool = False) -> np.ndarray: + """Pack a release-like test store with fov0006; return that FOV's array.""" + data = np.arange(np.prod(_SHAPE), dtype=np.float32).reshape(_SHAPE) + if negative: + data[2, 2, 6, 10, 12] = -1.0 # inside the crop: t=2, target channel + store = src_dir / f"{marker}_mock.zarr" + with open_ome_zarr( + store, layout="hcs", mode="w-", channel_names=["Phase3D", "Brightfield", target], version="0.5" + ) as plate: + for fov in ("fov0000", "fov0006"): + pos = plate.create_position("0", "0", fov) + pos.create_image( + "0", + data if fov == "fov0006" else np.zeros(_SHAPE, np.float32), + transform=[TransformationMeta(type="scale", scale=[1.0, 1.0, 0.174, 0.1494, 0.1494])], + ) + pos.zattrs["hpi_values"] = _HPI + pack_ozx(store, src_dir / f"{marker}_mock.ozx") + return data + + +@pytest.fixture +def small_crop(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path: + """Point the builder at ``tmp_path/src`` with a 4 x 8 x 8 crop.""" + src = tmp_path / "src" + src.mkdir() + monkeypatch.setattr(build_demo_data, "RELEASE_TEST", src) + monkeypatch.setattr(build_demo_data, "Z_SIZE", 4) + monkeypatch.setattr(build_demo_data, "YX_SIZE", 8) + return src + + +def test_main_crops_fov0006_and_zips_store_at_root( + small_crop: Path, tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + data = _write_release_ozx(small_crop, "CAAX", "Membrane") + monkeypatch.setattr(build_demo_data, "MARKERS", ("CAAX",)) + out = tmp_path / "out" + monkeypatch.setattr(sys, "argv", ["build_demo_data.py", str(out)]) + + build_demo_data.main() + + zip_path = out / "CAAX_mock.zarr.zip" + assert sorted(p.name for p in out.iterdir()) == ["CAAX_mock.zarr.zip"] + with zipfile.ZipFile(zip_path) as zf: + assert {n.split("/")[0] for n in zf.namelist()} == {"CAAX_mock.zarr"} + zf.extractall(tmp_path / "unzipped") + with open_ome_zarr(tmp_path / "unzipped" / "CAAX_mock.zarr", mode="r") as plate: + names = [name for name, _ in plate.positions()] + assert names == ["0/0/fov0006"] + pos = plate["0/0/fov0006"] + assert pos.channel_names == ["Phase3D", "Brightfield", "Membrane"] + assert pos.scale == [1.0, 1.0, 0.174, 0.1494, 0.1494] + # Central (12-4)//2, (20-8)//2, (24-8)//2 = (4, 6, 8), timepoints 0,2,4,6,8. + expected = data[[0, 2, 4, 6, 8], :, 4:8, 6:14, 8:16] + np.testing.assert_array_equal(np.asarray(pos.data), expected) + assert pos.zattrs["dynacell_demo"] == { + "source": "s3://dynacell/v1/data/biohub-a549/test/CAAX_mock.ozx", + "position": "0/0/fov0006", + "timepoints": [0, 2, 4, 6, 8], + "hpi_values": [5.0, 9.0, 13.0, 17.0, 21.0], + "zyx_offset": [4, 6, 8], + "zyx_size": [4, 8, 8], + } + + +def test_build_store_rejects_negative_target(small_crop: Path, tmp_path: Path) -> None: + _write_release_ozx(small_crop, "SEC61B", "Structure", negative=True) + with pytest.raises(ValueError, match="negative target pixels"): + build_demo_data.build_store("SEC61B", tmp_path) + assert not (tmp_path / "SEC61B_mock.zarr").exists() diff --git a/applications/dynacell/examples/hf_demo/cards/checkpoints_README.md b/applications/dynacell/examples/hf_demo/cards/checkpoints_README.md index 8e145ee81..f1b28d396 100644 --- a/applications/dynacell/examples/hf_demo/cards/checkpoints_README.md +++ b/applications/dynacell/examples/hf_demo/cards/checkpoints_README.md @@ -32,8 +32,8 @@ Three architectures, each trained per organelle (12 checkpoints total): ## Targets -All models take a single `Phase3D` input channel (`z_window_size=16`, -`512×512` YX) and predict one fluorescence target: +All models take a single `Phase3D` input channel (`512×512` YX; Z window 32 for +FNet3D, 15 for VSCyto3D, 8 for CELL-Diff) and predict one fluorescence target: | Organelle marker | Predicted channel | | --- | --- | @@ -44,6 +44,10 @@ All models take a single `Phase3D` input channel (`z_window_size=16`, ## Files +These are the A549-trained checkpoints of the DynaCell v1 release, byte-identical to +`s3://dynacell/v1/models/a549/{organelle}/{model}/` (organelle `membrane`, `nucleus`, +`er`, `mito`; see that prefix's `README.md` and `checkpoints.csv`). + `{model}_{organelle}.ckpt`, e.g. `celldiff_caax.ckpt`, `fnet3d_h2b.ckpt`, `vscyto3d_sec61b.ckpt` — `model ∈ {celldiff, fnet3d, vscyto3d}`, `organelle ∈ {caax, h2b, sec61b, tomm20}`. @@ -67,7 +71,9 @@ See the [demo Space](https://huggingface.co/spaces/biohub/dynacell) and ## Training data Live A549 cells imaged on the mantis microscope (phase contrast + paired -fluorescence ground truth). +fluorescence ground truth), training split of the DynaCell release +(`s3://dynacell/v1/data/biohub-a549/train/`). ER and mitochondria targets are raw +(not deconvolved) fluorescence. ## License @@ -75,12 +81,14 @@ BSD 3-Clause — © CZ Biohub SF. ## Citation -Please cite the DynaCell study and VisCy. - ```bibtex -@software{viscy, - title = {VisCy: computer vision for virtual staining of cells}, - author = {CZ Biohub SF and contributors}, - url = {https://github.com/mehta-lab/VisCy} +@inproceedings{kalinin2026dynacell, + title = {{DynaCell}: An Evaluation Framework for Dynamic {3D} Virtual Staining of Live Cells}, + author = {Kalinin, Alexandr A. and Zheng, Dihan and Theodoro, Taylla Milena and + Ivanov, Ivan and Hirata-Miyasaki, Eduardo and Lee, See-Chi and Liu, Aofei and + Varra, Sricharan Reddy and Chandler, Talon and Pradeep, Soorya and Liu, Chad and + Leonetti, Manuel D. and Arias, Carolina and Huang, Bo and Mehta, Shalin B.}, + booktitle = {Advances in Neural Information Processing Systems (NeurIPS 2026), Evaluations and Datasets Track}, + year = {2026} } ``` diff --git a/applications/dynacell/examples/hf_demo/cards/demo_data_README.md b/applications/dynacell/examples/hf_demo/cards/demo_data_README.md index 17e513fac..968af7eba 100644 --- a/applications/dynacell/examples/hf_demo/cards/demo_data_README.md +++ b/applications/dynacell/examples/hf_demo/cards/demo_data_README.md @@ -16,8 +16,8 @@ tags: Paired phase-contrast + fluorescence OME-Zarr datasets used by the [`biohub/dynacell`](https://huggingface.co/spaces/biohub/dynacell) virtual-staining -demo. Each file is one live-cell **A549** acquisition with a different fluorescent -organelle marker, zipped as a single OME-Zarr HCS store. +demo. Each file is one held-out live-cell **A549** field of view with a different +fluorescent organelle marker, zipped as a single OME-Zarr HCS store. Companion checkpoints: [`biohub/dynacell-checkpoints`](https://huggingface.co/biohub/dynacell-checkpoints). @@ -25,22 +25,32 @@ Companion checkpoints: [`biohub/dynacell-checkpoints`](https://huggingface.co/bi | File | Marker | Target | Size | | --- | --- | --- | --- | -| `CAAX_mock.zarr.zip` | CAAX | Membrane | ~188 MB | -| `H2B_mock.zarr.zip` | H2B | Nuclei / chromatin | ~184 MB | -| `SEC61B_mock.zarr.zip` | SEC61B | ER | ~156 MB | -| `TOMM20_mock.zarr.zip` | TOMM20 | Mitochondria | ~156 MB | +| `CAAX_mock.zarr.zip` | CAAX | Membrane | ~381 MB | +| `H2B_mock.zarr.zip` | H2B | Nuclei / chromatin | ~372 MB | +| `SEC61B_mock.zarr.zip` | SEC61B | ER | ~314 MB | +| `TOMM20_mock.zarr.zip` | TOMM20 | Mitochondria | ~315 MB | `mock` denotes the uninfected (control) imaging condition. +## Provenance + +Each store is a crop of `fov0006` from the DynaCell v1 **test** split, +`s3://dynacell/v1/data/biohub-a549/test/{marker}_mock.ozx`: timepoints 0, 2, 4, 6, 8 +(5–21 hpi), the central 32 of 48 Z slices, and the central 512×512 of the 640×960 field +of view. The crop is recorded in each position's `dynacell_demo` attributes and is +rebuilt by `build_demo_data.py` in +[VisCy](https://github.com/mehta-lab/VisCy/tree/dynacell-models/applications/dynacell/examples/hf_demo). +ER and mitochondria targets are raw (not deconvolved) fluorescence, as used for +training and evaluation. + ## Layout Each `.zip` unpacks to an OME-Zarr HCS store: ``` {marker}_mock.zarr/ - 0/0/fov0000/0 # array (T, C, Z, Y, X) - # C[0] = Phase3D (input), C[2] = experimental fluorescence (target) - # Z = 16, YX = 512×512 + 0/0/fov0006/0 # array (T, C, Z, Y, X) = (5, 3, 32, 512, 512), float32 + # C = Phase3D (input), Brightfield, experimental fluorescence (target) ``` ## Usage @@ -63,4 +73,14 @@ BSD 3-Clause — © CZ Biohub SF. ## Citation -Please cite the DynaCell study and VisCy. +```bibtex +@inproceedings{kalinin2026dynacell, + title = {{DynaCell}: An Evaluation Framework for Dynamic {3D} Virtual Staining of Live Cells}, + author = {Kalinin, Alexandr A. and Zheng, Dihan and Theodoro, Taylla Milena and + Ivanov, Ivan and Hirata-Miyasaki, Eduardo and Lee, See-Chi and Liu, Aofei and + Varra, Sricharan Reddy and Chandler, Talon and Pradeep, Soorya and Liu, Chad and + Leonetti, Manuel D. and Arias, Carolina and Huang, Bo and Mehta, Shalin B.}, + booktitle = {Advances in Neural Information Processing Systems (NeurIPS 2026), Evaluations and Datasets Track}, + year = {2026} +} +``` diff --git a/applications/dynacell/examples/hf_demo/hf_space/README.md b/applications/dynacell/examples/hf_demo/hf_space/README.md index 718833c32..9956ff77c 100644 --- a/applications/dynacell/examples/hf_demo/hf_space/README.md +++ b/applications/dynacell/examples/hf_demo/hf_space/README.md @@ -17,26 +17,28 @@ datasets: # DynaCell Virtual Staining Demo -Predict fluorescence channels (membrane, nuclei, or organelle structure) from phase-contrast OME-Zarr using three models: +Predict fluorescence (membrane, nuclei, ER, mitochondria) from label-free phase 3-D +microscopy of live A549 cells with three DynaCell baselines: -- **CELL-Diff** — flow-matching diffusion model -- **FNet3D** — 3-D U-Net (FNet architecture) -- **VSCyto3D** — masked-autoencoder pretrained U-Net +- **FNet3D**: 3-D U-Net (deterministic regression) +- **VSCyto3D**: FCMAE-pretrained UNeXt2 (deterministic regression) +- **CELL-Diff**: flow-matching diffusion model; scrub its ODE trajectory from noise to prediction -## Quick start +The page has three sections: **Data** (browse phase and experimental fluorescence), +**Regression** (FNet3D and VSCyto3D with Spectral PCC against the experimental channel) and +**Generative** (CELL-Diff). Inference runs on the selected timepoint only. -1. Select an organelle from the dropdown. -2. Click **Load Demo Data** to fetch the matching A549-cell demo dataset directly into the Space — no download/upload needed. -3. Run predictions in **Tab 1** or generate the CELL-Diff ODE trajectory in **Tab 2**. +## Quick start -## Using your own data +1. Select an organelle and click **Load Demo Data**. +2. Run the regression models, or generate the CELL-Diff trajectory. -The input must be an OME-Zarr HCS store zipped into a single `.zip` file, with layout: +## Data and checkpoints -``` -your_data.zarr/ - 0/0/fov0000/0 # array shape (T, C, Z, Y, X) - # C[0] = Phase3D, Z = 16, YX = 512×512 -``` +Demo data ([`biohub/dynacell-demo-data`](https://huggingface.co/datasets/biohub/dynacell-demo-data)) +is one held-out test field of view per marker, cropped from the DynaCell v1 release +(`s3://dynacell/v1/data/biohub-a549/test/`). The checkpoints +([`biohub/dynacell-checkpoints`](https://huggingface.co/biohub/dynacell-checkpoints)) are the +released A549-trained models (`s3://dynacell/v1/models/a549/`). -Use [iohub](https://github.com/czbiohub-sf/iohub) to create compatible zarr stores. +Code: [VisCy `applications/dynacell`](https://github.com/mehta-lab/VisCy/tree/dynacell-models/applications/dynacell). diff --git a/applications/dynacell/examples/hf_demo/hf_space/app.py b/applications/dynacell/examples/hf_demo/hf_space/app.py index 8aad80558..60b23e0da 100644 --- a/applications/dynacell/examples/hf_demo/hf_space/app.py +++ b/applications/dynacell/examples/hf_demo/hf_space/app.py @@ -50,20 +50,31 @@ GEN_PANEL_IN = 3.0 GEN_FIG_H = 3.6 +# Theme sync. HF embeds the Space as `?__theme=system`, which only the browser can resolve, +# so the browser reports the theme Gradio applied (the `dark` class on ). On page load +# an observer is installed that clicks the hidden #theme-sync button whenever that class +# flips (OS scheme change, Settings toggle), which re-reads the theme and re-renders. +IS_DARK_JS = "() => document.body.classList.contains('dark')" +THEME_INIT_JS = """ +() => { + const isDark = () => document.body.classList.contains('dark'); + let last = isDark(); + new MutationObserver(() => { + if (isDark() !== last) { + last = isDark(); + document.getElementById('theme-sync').click(); + } + }).observe(document.body, {attributes: true, attributeFilter: ['class']}); + return last; +} +""" + # --------------------------------------------------------------------------- # Helpers # --------------------------------------------------------------------------- -def is_dark(request: gr.Request | None) -> bool: - """Detect the client theme from the `__theme` query param (default: dark).""" - try: - return (request.query_params.get("__theme") or "dark").lower() != "light" - except Exception: - return True - - def style_fig(fig, dark: bool) -> None: """Match the figure to the themed widget background: transparent panel, themed text.""" fg = "white" if dark else "black" @@ -261,7 +272,7 @@ def render_trajectory_frame( # --------------------------------------------------------------------------- -def load_demo_data(organelle: str, progress=gr.Progress(), request: gr.Request | None = None) -> tuple: +def load_demo_data(organelle: str, dark: bool, progress=gr.Progress()) -> tuple: """Download + extract the demo zarr; set every section's slider ranges; render view.""" from huggingface_hub import hf_hub_download @@ -273,7 +284,7 @@ def load_demo_data(organelle: str, progress=gr.Progress(), request: gr.Request | n_tp, n_z = get_data_shape(data_path) z_mid = n_z // 2 z_start = (n_z - PATCH_D) // 2 - fig = render_phase_exp(data_path, 0, z_mid, organelle, is_dark(request)) + fig = render_phase_exp(data_path, 0, z_mid, organelle, dark) status = f"**Loaded:** {filename} · {n_tp} timepoints · {n_z} Z slices" progress(1.0, desc="Ready.") @@ -300,12 +311,12 @@ def on_data_slider( organelle: str, timepoint: int, z_slice: int, - request: gr.Request | None = None, + dark: bool, ) -> plt.Figure | None: """Re-render the data view on T/Z change.""" if not zarr_state: return None - return render_phase_exp(zarr_state, timepoint, z_slice, organelle, is_dark(request)) + return render_phase_exp(zarr_state, timepoint, z_slice, organelle, dark) # --------------------------------------------------------------------------- @@ -319,8 +330,8 @@ def run_regression( selected_models: list[str], timepoint: int, z_slice: int, + dark: bool, progress=gr.Progress(), - request: gr.Request | None = None, ) -> tuple[plt.Figure | None, dict]: if not zarr_state: raise gr.Error("Load demo data first.") @@ -359,7 +370,7 @@ def run_regression( "n_z": n_z, } progress(0.9, desc="Rendering...") - fig = render_predictions(pred_info, min(int(z_slice), n_z - 1), zarr_state, is_dark(request)) + fig = render_predictions(pred_info, min(int(z_slice), n_z - 1), zarr_state, dark) progress(1.0, desc="Done.") return fig, pred_info @@ -368,12 +379,12 @@ def rerender_regression( pred_info: dict | None, z_slice: int, zarr_state: str | None, - request: gr.Request | None = None, + dark: bool, ) -> plt.Figure | None: """Re-render regression predictions at a new Z slice (no re-prediction).""" if pred_info is None or not zarr_state: return None - return render_predictions(pred_info, int(z_slice), zarr_state, is_dark(request)) + return render_predictions(pred_info, int(z_slice), zarr_state, dark) # --------------------------------------------------------------------------- @@ -387,8 +398,8 @@ def run_generative( timepoint: int, num_steps: int, z_slice: int, + dark: bool, progress=gr.Progress(), - request: gr.Request | None = None, ) -> tuple: if not zarr_state: raise gr.Error("Load demo data first.") @@ -399,7 +410,7 @@ def run_generative( n = int(num_steps) last = n - 1 progress(0.95, desc="Rendering final step...") - fig = render_trajectory_frame(traj_info, int(z_slice), last, is_dark(request)) + fig = render_trajectory_frame(traj_info, int(z_slice), last, dark) step_slider = gr.Slider(minimum=0, maximum=last, step=1, value=last, label="ODE step") progress(1.0, desc="Done.") return fig, traj_info, step_slider @@ -409,19 +420,39 @@ def rerender_generative( traj_info: dict | None, z_slice: int, step: int, - request: gr.Request | None = None, + dark: bool, ) -> plt.Figure | None: """Re-render the trajectory frame at a new ODE step / Z slice (no ODE re-run).""" if traj_info is None: return None - return render_trajectory_frame(traj_info, int(z_slice), int(step), is_dark(request)) + return render_trajectory_frame(traj_info, int(z_slice), int(step), dark) + + +def rerender_all( + zarr_state: str | None, + organelle: str, + data_t: int, + data_z: int, + reg_pred_info: dict | None, + reg_z: int, + traj_info: dict | None, + gen_z: int, + gen_step: int, + dark: bool, +) -> tuple: + """Re-render all three plots in the current theme (no inference re-run).""" + return ( + on_data_slider(zarr_state, organelle, data_t, data_z, dark), + rerender_regression(reg_pred_info, reg_z, zarr_state, dark), + rerender_generative(traj_info, gen_z, gen_step, dark), + ) # --------------------------------------------------------------------------- # UI # --------------------------------------------------------------------------- -with gr.Blocks(title="DynaCell Virtual Staining") as demo: +with gr.Blocks(title="DynaCell Virtual Staining", css="#theme-sync {display: none !important;}") as demo: gr.Markdown("## DynaCell Virtual Staining Demo") gr.Markdown( "Predict fluorescence from label-free phase-contrast 3-D microscopy of live " @@ -432,6 +463,8 @@ def rerender_generative( zarr_state = gr.State(value=None) reg_pred_state = gr.State(value=None) traj_state = gr.State(value=None) + dark_mode = gr.Checkbox(value=True, visible=False) # set from the browser, see THEME_INIT_JS + theme_sync = gr.Button(elem_id="theme-sync") # clicked by the theme observer; hidden by CSS # ---- 1. Data --------------------------------------------------------- gr.Markdown("### 1.  Data") @@ -445,7 +478,7 @@ def rerender_generative( ) load_demo_btn = gr.Button("Load Demo Data", variant="primary") data_t = gr.Slider(0, 4, step=1, value=0, label="Timepoint") - data_z = gr.Slider(0, 15, step=1, value=8, label="Z slice") + data_z = gr.Slider(0, 31, step=1, value=16, label="Z slice") data_status = gr.Markdown("") with gr.Column(scale=2): data_view = gr.Plot(label="Phase | Experimental fluorescence") @@ -461,7 +494,7 @@ def rerender_generative( label="Models", ) reg_t = gr.Slider(0, 4, step=1, value=0, label="Timepoint") - reg_z = gr.Slider(0, 15, step=1, value=8, label="Z slice") + reg_z = gr.Slider(0, 31, step=1, value=16, label="Z slice") reg_run_btn = gr.Button("Run regression", variant="primary") with gr.Column(scale=2): reg_plot = gr.Plot(label="Predictions") @@ -471,9 +504,9 @@ def rerender_generative( gr.Markdown("### 3.  Generative model: CELL-Diff") with gr.Row(): with gr.Column(scale=1): - gen_steps = gr.Slider(10, 100, step=10, value=50, label="ODE steps") + gen_steps = gr.Slider(8, 24, step=1, value=8, label="ODE time points") gen_t = gr.Slider(0, 4, step=1, value=0, label="Timepoint") - gen_z = gr.Slider(4, 11, step=1, value=8, label="Z slice") + gen_z = gr.Slider(12, 19, step=1, value=16, label="Z slice") gr.Markdown("_CELL-Diff inference requires 8 input slices._") gen_btn = gr.Button("Generate", variant="primary") gen_step = gr.Slider(0, 1, step=1, value=0, label="ODE step", info="Slide after generating.") @@ -481,28 +514,38 @@ def rerender_generative( gen_plot = gr.Plot(label="Phase | Exp | Trajectory") # ---- Wiring ---------------------------------------------------------- + # A js-only event never runs its .then() on the backend (Gradio 5.29), but it does fire + # .change on the component it updates. + demo.load(None, None, [dark_mode], js=THEME_INIT_JS) + theme_sync.click(None, None, [dark_mode], js=IS_DARK_JS) + dark_mode.change( + rerender_all, + [zarr_state, organelle, data_t, data_z, reg_pred_state, reg_z, traj_state, gen_z, gen_step, dark_mode], + [data_view, reg_plot, gen_plot], + ) + load_demo_btn.click( load_demo_data, - [organelle], + [organelle, dark_mode], [zarr_state, data_status, data_t, data_z, reg_t, reg_z, gen_t, gen_z, data_view], ) for _trigger in (data_t, data_z): - _trigger.change(on_data_slider, [zarr_state, organelle, data_t, data_z], [data_view]) + _trigger.change(on_data_slider, [zarr_state, organelle, data_t, data_z, dark_mode], [data_view]) reg_run_btn.click( run_regression, - [zarr_state, organelle, reg_models, reg_t, reg_z], + [zarr_state, organelle, reg_models, reg_t, reg_z, dark_mode], [reg_plot, reg_pred_state], ) - reg_z.change(rerender_regression, [reg_pred_state, reg_z, zarr_state], [reg_plot]) + reg_z.change(rerender_regression, [reg_pred_state, reg_z, zarr_state, dark_mode], [reg_plot]) gen_btn.click( run_generative, - [zarr_state, organelle, gen_t, gen_steps, gen_z], + [zarr_state, organelle, gen_t, gen_steps, gen_z, dark_mode], [gen_plot, traj_state, gen_step], ) for _trigger in (gen_step, gen_z): - _trigger.change(rerender_generative, [traj_state, gen_z, gen_step], [gen_plot]) + _trigger.change(rerender_generative, [traj_state, gen_z, gen_step, dark_mode], [gen_plot]) if __name__ == "__main__": diff --git a/applications/dynacell/examples/hf_demo/hf_space/config_templates/celldiff.yaml b/applications/dynacell/examples/hf_demo/hf_space/config_templates/celldiff.yaml index 05ffb3ea1..abb1a9d52 100644 --- a/applications/dynacell/examples/hf_demo/hf_space/config_templates/celldiff.yaml +++ b/applications/dynacell/examples/hf_demo/hf_space/config_templates/celldiff.yaml @@ -25,7 +25,7 @@ data: data_path: {data_path} source_channel: Phase3D target_channel: {target_channel} - z_window_size: 16 + z_window_size: 32 batch_size: 1 num_workers: 0 yx_patch_size: [512, 512] @@ -42,6 +42,7 @@ trainer: devices: 1 num_nodes: 1 precision: 32-true + logger: false callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: diff --git a/applications/dynacell/examples/hf_demo/hf_space/config_templates/fnet3d.yaml b/applications/dynacell/examples/hf_demo/hf_space/config_templates/fnet3d.yaml index 6b000cc55..e0715e2e8 100644 --- a/applications/dynacell/examples/hf_demo/hf_space/config_templates/fnet3d.yaml +++ b/applications/dynacell/examples/hf_demo/hf_space/config_templates/fnet3d.yaml @@ -7,7 +7,7 @@ model: out_channels: 1 depth: 4 mult_chan: 32 - in_stack_depth: 16 + in_stack_depth: 32 predict_method: full_image predict_overlap: [4, 256, 256] ckpt_path: {ckpt_path} @@ -18,7 +18,7 @@ data: data_path: {data_path} source_channel: Phase3D target_channel: {target_channel} - z_window_size: 16 + z_window_size: 32 batch_size: 1 num_workers: 0 yx_patch_size: [512, 512] @@ -37,6 +37,7 @@ trainer: devices: 1 num_nodes: 1 precision: 32-true + logger: false callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: diff --git a/applications/dynacell/examples/hf_demo/hf_space/config_templates/vscyto3d.yaml b/applications/dynacell/examples/hf_demo/hf_space/config_templates/vscyto3d.yaml index a01682460..6678e2048 100644 --- a/applications/dynacell/examples/hf_demo/hf_space/config_templates/vscyto3d.yaml +++ b/applications/dynacell/examples/hf_demo/hf_space/config_templates/vscyto3d.yaml @@ -41,6 +41,7 @@ trainer: devices: 1 num_nodes: 1 precision: 32-true + logger: false callbacks: - class_path: viscy_utils.callbacks.prediction_writer.HCSPredictionWriter init_args: diff --git a/applications/dynacell/examples/hf_demo/hf_space/predict_runner.py b/applications/dynacell/examples/hf_demo/hf_space/predict_runner.py index e8a8df926..f69c1be7d 100644 --- a/applications/dynacell/examples/hf_demo/hf_space/predict_runner.py +++ b/applications/dynacell/examples/hf_demo/hf_space/predict_runner.py @@ -52,6 +52,11 @@ SPACING = [0.174, 0.1494, 0.1494] SPECTRAL_KWARGS = dict(bin_delta=1.0, tail_fraction=0.2, apodization="tukey", nbins_low=3) +# CELL-Diff trajectory sampler: fixed-step midpoint on a Beta(0.4, 0.3) time grid, the +# DynaCell-lite recipe (#520). 8 time points = 14 network evaluations, vs ~80-100 for the +# adaptive dopri5 default, with the same image (relL2 0.03-0.06 to dopri5 on the demo data). +TRAJ_SAMPLER = dict(sampling_method="midpoint", time_schedule=(0.4, 0.3)) + # Cache downloaded checkpoints in /tmp so the Space doesn't re-download each run _ckpt_cache: dict[str, str] = {} @@ -167,7 +172,7 @@ def compute_trajectory( organelle: str, data_path: str, timepoint: int = 0, - num_steps: int = 50, + num_steps: int = 8, progress=None, ) -> dict: """Run the CELL-Diff ODE; save trajectory to /tmp as .npy; return metadata dict. @@ -217,11 +222,12 @@ def compute_trajectory( gt_crop = fluor_raw[z_start : z_start + patch_d, :patch_h, :patch_w].astype(np.float32) if progress is not None: - progress(0.35, desc=f"Generating {num_steps}-step ODE trajectory...") + progress(0.35, desc=f"Generating {num_steps}-point ODE trajectory...") phase_tensor = torch.from_numpy(phase_crop).float().unsqueeze(0).unsqueeze(0).to(device) - with torch.no_grad(): - trajectory = model.model.generate_trajectory(phase_tensor, num_steps=num_steps) - traj_np = trajectory[:, 0].cpu().numpy().astype(np.float32) # (num_steps, 1, D, H, W) + # bf16 autocast: same lite-benchmark ordering as fp32; GroupNorm stays fp32 in the net. + with torch.no_grad(), torch.autocast(device, dtype=torch.bfloat16, enabled=device == "cuda"): + trajectory = model.model.generate_trajectory(phase_tensor, num_steps=num_steps, **TRAJ_SAMPLER) + traj_np = trajectory[:, 0].float().cpu().numpy() # (num_steps, 1, D, H, W) if progress is not None: progress(0.90, desc="Saving trajectory to disk...") diff --git a/applications/dynacell/examples/hf_demo/hf_space/requirements.txt b/applications/dynacell/examples/hf_demo/hf_space/requirements.txt index 470565ace..f18bd0e7c 100644 --- a/applications/dynacell/examples/hf_demo/hf_space/requirements.txt +++ b/applications/dynacell/examples/hf_demo/hf_space/requirements.txt @@ -6,9 +6,9 @@ matplotlib>=3.7 torch>=2.1 huggingface_hub>=0.20 iohub>=0.3.6 -cubic==0.7.0a12 -git+https://github.com/mehta-lab/VisCy.git@dynacell-models#subdirectory=packages/viscy-data -git+https://github.com/mehta-lab/VisCy.git@dynacell-models#subdirectory=packages/viscy-models -git+https://github.com/mehta-lab/VisCy.git@dynacell-models#subdirectory=packages/viscy-transforms -git+https://github.com/mehta-lab/VisCy.git@dynacell-models#subdirectory=packages/viscy-utils -git+https://github.com/mehta-lab/VisCy.git@dynacell-models#subdirectory=applications/dynacell +cubic==0.9.0a1 +git+https://github.com/mehta-lab/VisCy.git@84cc1ae7eaa3ec0d654d5ea7087c594588faf146#subdirectory=packages/viscy-data +git+https://github.com/mehta-lab/VisCy.git@84cc1ae7eaa3ec0d654d5ea7087c594588faf146#subdirectory=packages/viscy-models +git+https://github.com/mehta-lab/VisCy.git@84cc1ae7eaa3ec0d654d5ea7087c594588faf146#subdirectory=packages/viscy-transforms +git+https://github.com/mehta-lab/VisCy.git@84cc1ae7eaa3ec0d654d5ea7087c594588faf146#subdirectory=packages/viscy-utils +git+https://github.com/mehta-lab/VisCy.git@84cc1ae7eaa3ec0d654d5ea7087c594588faf146#subdirectory=applications/dynacell diff --git a/applications/dynacell/examples/hf_demo/upload_checkpoints.py b/applications/dynacell/examples/hf_demo/upload_checkpoints.py index 4370f0b4c..38a5f4700 100644 --- a/applications/dynacell/examples/hf_demo/upload_checkpoints.py +++ b/applications/dynacell/examples/hf_demo/upload_checkpoints.py @@ -1,4 +1,4 @@ -"""Upload all 12 dynacell checkpoints to biohub/dynacell-checkpoints on HF Hub. +"""Upload the 12 released A549 dynacell checkpoints to biohub/dynacell-checkpoints on HF Hub. The repo is private and lives in the biohub "Dynacell" resource group (see AGENT.md). Run this from the HPC where checkpoints are stored: @@ -16,74 +16,35 @@ # biohub "Dynacell" resource group (see AGENT.md). RESOURCE_GROUP_ID = "6a234bb4507cbbbb04456767" -# (hf_filename, local_path) +# Release zoo root (mirrors s3://dynacell/v1/models/); see models/checkpoints.csv. +RELEASE_A549 = "/hpc/projects/virtual_staining/dynacell_v1/models/a549" + +# (hf_filename, local_path) -- the released A549-trained checkpoints. CHECKPOINTS: list[tuple[str, str]] = [ - ( - "celldiff_caax.ckpt", - "/hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy" - "/a549_mantis/memb/celldiff_r2/checkpoints/last.ckpt", - ), - ( - "celldiff_h2b.ckpt", - "/hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy" - "/a549_mantis/nucl/celldiff_r2/checkpoints/last.ckpt", - ), - ( - "celldiff_sec61b.ckpt", - "/hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy" - "/a549_mantis/sec61b/celldiff_r2/checkpoints/last.ckpt", - ), - ( - "celldiff_tomm20.ckpt", - "/hpc/projects/comp.micro/virtual_staining/models/cell_diff_vs_viscy" - "/a549_mantis/tomm20/celldiff_r2/checkpoints/last.ckpt", - ), - ( - "fnet3d_caax.ckpt", - "/hpc/projects/comp.micro/virtual_staining/models/dynacell" - "/a549_mantis/memb/fnet3d_paper/checkpoints/epoch=281-step=191760.ckpt", - ), - ( - "fnet3d_h2b.ckpt", - "/hpc/projects/comp.micro/virtual_staining/models/dynacell" - "/a549_mantis/nucl/fnet3d_paper/checkpoints/epoch=293-step=199920.ckpt", - ), - ( - "fnet3d_sec61b.ckpt", - "/hpc/projects/comp.micro/virtual_staining/models/dynacell" - "/a549_mantis/sec61b/fnet3d_paper/checkpoints/last.ckpt", - ), - ( - "fnet3d_tomm20.ckpt", - "/hpc/projects/comp.micro/virtual_staining/models/dynacell" - "/a549_mantis/tomm20/fnet3d_paper/checkpoints/epoch=248-step=126990.ckpt", - ), - ( - "vscyto3d_caax.ckpt", - "/hpc/projects/comp.micro/virtual_staining/models/dynacell" - "/a549_mantis/memb/fcmae_vscyto3d_pretrained/checkpoints/last.ckpt", - ), - ( - "vscyto3d_h2b.ckpt", - "/hpc/projects/comp.micro/virtual_staining/models/dynacell" - "/a549_mantis/nucl/fcmae_vscyto3d_pretrained/checkpoints/last.ckpt", - ), - ( - "vscyto3d_sec61b.ckpt", - "/hpc/projects/comp.micro/virtual_staining/models/dynacell" - "/a549_mantis/sec61b/fcmae_vscyto3d_pretrained_ws8500/checkpoints/last.ckpt", - ), - ( - "vscyto3d_tomm20.ckpt", - "/hpc/projects/comp.micro/virtual_staining/models/dynacell" - "/a549_mantis/tomm20/fcmae_vscyto3d_pretrained_ws8500/checkpoints/last.ckpt", - ), + ("celldiff_caax.ckpt", f"{RELEASE_A549}/membrane/celldiff/epoch=19-step=86400.ckpt"), + ("celldiff_h2b.ckpt", f"{RELEASE_A549}/nucleus/celldiff/epoch=19-step=86400.ckpt"), + ("celldiff_sec61b.ckpt", f"{RELEASE_A549}/er/celldiff/epoch=19-step=66240-v1.ckpt"), + ("celldiff_tomm20.ckpt", f"{RELEASE_A549}/mito/celldiff/epoch=19-step=64800-v1.ckpt"), + ("fnet3d_caax.ckpt", f"{RELEASE_A549}/membrane/fnet3d/epoch=281-step=191760.ckpt"), + ("fnet3d_h2b.ckpt", f"{RELEASE_A549}/nucleus/fnet3d/epoch=293-step=199920.ckpt"), + ("fnet3d_sec61b.ckpt", f"{RELEASE_A549}/er/fnet3d/epoch=350-step=185679.ckpt"), + ("fnet3d_tomm20.ckpt", f"{RELEASE_A549}/mito/fnet3d/epoch=170-step=87210.ckpt"), + ("vscyto3d_caax.ckpt", f"{RELEASE_A549}/membrane/vscyto3d/epoch=121-step=26474.ckpt"), + ("vscyto3d_h2b.ckpt", f"{RELEASE_A549}/nucleus/vscyto3d/epoch=134-step=29295.ckpt"), + ("vscyto3d_sec61b.ckpt", f"{RELEASE_A549}/er/vscyto3d/epoch=106-step=18404.ckpt"), + ("vscyto3d_tomm20.ckpt", f"{RELEASE_A549}/mito/vscyto3d/epoch=115-step=18328.ckpt"), ] def main() -> None: import os + # Check every file first: a missing one found mid-loop would leave the repo + # half old, half new. + missing = [path for _, path in CHECKPOINTS if not Path(path).is_file()] + if missing: + raise FileNotFoundError(f"release checkpoints not found: {missing}") + token = os.environ.get("HF_TOKEN") api = HfApi(token=token) @@ -100,9 +61,6 @@ def main() -> None: for hf_name, local_path in CHECKPOINTS: local = Path(local_path) - if not local.exists(): - print(f" SKIP (not found): {local_path}") - continue print(f" Uploading {hf_name} ({local.stat().st_size / 1e9:.2f} GB) ...") api.upload_file( path_or_fileobj=str(local), @@ -112,7 +70,13 @@ def main() -> None: ) print(f" Done: {hf_name}") - print("\nAll checkpoints uploaded.") + api.upload_file( + path_or_fileobj=str(Path(__file__).parent / "cards" / "checkpoints_README.md"), + path_in_repo="README.md", + repo_id=REPO_ID, + repo_type="model", + ) + print("\nAll checkpoints and the model card uploaded.") if __name__ == "__main__": diff --git a/applications/dynacell/examples/hf_demo/upload_demo_data.py b/applications/dynacell/examples/hf_demo/upload_demo_data.py new file mode 100644 index 000000000..367be8f96 --- /dev/null +++ b/applications/dynacell/examples/hf_demo/upload_demo_data.py @@ -0,0 +1,51 @@ +"""Upload the demo-data zips and card to biohub/dynacell-demo-data on HF Hub. + +The dataset repo is private and lives in the biohub "Dynacell" resource group (see +AGENT.md). Build the zips first with build_demo_data.py, then: + + hf auth login # or set HF_TOKEN env var + python upload_demo_data.py ZIP_DIR +""" + +import argparse +import os +from pathlib import Path + +from huggingface_hub import HfApi, create_repo + +REPO_ID = "biohub/dynacell-demo-data" +# biohub "Dynacell" resource group (see AGENT.md). +RESOURCE_GROUP_ID = "6a234bb4507cbbbb04456767" +MARKERS = ("CAAX", "H2B", "SEC61B", "TOMM20") + + +def main() -> None: + ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + ap.add_argument("zip_dir", type=Path) + args = ap.parse_args() + token = os.environ.get("HF_TOKEN") + api = HfApi(token=token) + create_repo( + REPO_ID, + repo_type="dataset", + private=True, + resource_group_id=RESOURCE_GROUP_ID, + exist_ok=True, + token=token, + ) + for marker in MARKERS: + name = f"{marker}_mock.zarr.zip" + path = args.zip_dir / name + print(f" Uploading {name} ({path.stat().st_size / 1e6:.0f} MB) ...") + api.upload_file(path_or_fileobj=str(path), path_in_repo=name, repo_id=REPO_ID, repo_type="dataset") + api.upload_file( + path_or_fileobj=str(Path(__file__).parent / "cards" / "demo_data_README.md"), + path_in_repo="README.md", + repo_id=REPO_ID, + repo_type="dataset", + ) + print(f"Done: https://huggingface.co/datasets/{REPO_ID}") + + +if __name__ == "__main__": + main() diff --git a/applications/dynacell/examples/hf_demo/upload_hf_space.py b/applications/dynacell/examples/hf_demo/upload_hf_space.py index acdece9b4..74d55d21d 100644 --- a/applications/dynacell/examples/hf_demo/upload_hf_space.py +++ b/applications/dynacell/examples/hf_demo/upload_hf_space.py @@ -39,6 +39,8 @@ def main() -> None: folder_path=str(HF_SPACE_DIR), repo_id=SPACE_REPO, repo_type="space", + ignore_patterns=["__pycache__/*", "*.pyc"], + delete_patterns=["__pycache__/*", "*.pyc"], ) print(f"\nDone. Space URL: https://huggingface.co/spaces/{SPACE_REPO}") diff --git a/applications/dynacell/examples/notebooks/get-to-know-dynacell-dataset.ipynb b/applications/dynacell/examples/notebooks/get-to-know-dynacell-dataset.ipynb index 1fd7d1781..510eccf0d 100644 --- a/applications/dynacell/examples/notebooks/get-to-know-dynacell-dataset.ipynb +++ b/applications/dynacell/examples/notebooks/get-to-know-dynacell-dataset.ipynb @@ -9,7 +9,7 @@ "\n", "Can a model look at a living cell under plain light and recover the organelles it cannot see? [DynaCell v1](https://registry.opendata.aws/dynacell/) is the benchmark built to answer that. It pairs label-free 3D microscopy (quantitative phase and brightfield) with fluorescence images of tagged organelles, the target a *virtual staining* model learns to reproduce.\n", "\n", - "The release spans two cell types (A549 lung epithelial cells and hiPSCs), four organelles (plasma membrane, chromatin, ER, mitochondria), and three infection states in A549 (mock, Dengue, Zika), about 677 GB. Rather than download any of it, this notebook **streams** slices straight from S3, fetching only the bytes it shows. It has three parts:\n", + "The release spans two cell types (A549 lung epithelial cells and hiPSCs), four organelles (plasma membrane, chromatin, ER, mitochondria), and three infection states in A549 (mock, Dengue, Zika), about 930 GB. Rather than download any of it, this notebook **streams** slices straight from S3, fetching only the bytes it shows. It has three parts:\n", "\n", "1. **What's in the bucket** explores the data layout and metadata.\n", "2. **Data diversity** shows the data across channels, conditions, and cell types.\n", @@ -32,9 +32,10 @@ "| `v1/data/` | OME-Zarr imaging archives, the dataset itself |\n", "| `v1/models/` | Pre-trained virtual-staining checkpoints |\n", "| `v1/demo/` | A <1 GB reviewer bundle for a quick taste |\n", + "| `v1/dynacell-qc-reports/` | Per-archive quality-control reports |\n", "| `v1/metadata/` · `v1/supplementary/` · `v1/README.md` | Croissant metadata, extras, and the top-level README |\n", "\n", - "Imaging archives split by source. **`biohub-a549/`** (387 GB, CC-BY-4.0) holds 24 files: four organelles (`CAAX` membrane, `H2B` chromatin, `SEC61B` ER, `TOMM20` mitochondria) × three conditions (`mock`, `DENV`, `ZIKV`) × two splits. **`aics-hipsc/`** (290 GB, Allen Institute terms) adds a second cell type with the same four organelles, but no infection conditions. Each file is one self-contained OME-Zarr plate. We list them with `boto3`, which needs no download." + "Imaging archives split by source. **`biohub-a549/`** (620 GB, CC-BY-4.0) holds 24 files: four organelles (`CAAX` membrane, `H2B` chromatin, `SEC61B` ER, `TOMM20` mitochondria) × three conditions (`mock`, `DENV`, `ZIKV`) × two splits. **`aics-hipsc/`** (309 GB, Allen Institute terms) adds a second cell type with the same four organelles, but no infection conditions. Each file is one self-contained OME-Zarr plate. We list them with `boto3`, which needs no download." ] }, { @@ -43,10 +44,10 @@ "id": "ssl-cert-setup", "metadata": { "execution": { - "iopub.execute_input": "2026-06-15T21:38:10.518310Z", - "iopub.status.busy": "2026-06-15T21:38:10.518201Z", - "iopub.status.idle": "2026-06-15T21:38:10.525138Z", - "shell.execute_reply": "2026-06-15T21:38:10.524766Z" + "iopub.execute_input": "2026-10-05T23:11:30.727455Z", + "iopub.status.busy": "2026-10-05T23:11:30.727339Z", + "iopub.status.idle": "2026-10-05T23:11:30.732998Z", + "shell.execute_reply": "2026-10-05T23:11:30.732676Z" } }, "outputs": [], @@ -72,10 +73,10 @@ "id": "imports-cell", "metadata": { "execution": { - "iopub.execute_input": "2026-06-15T21:38:10.526580Z", - "iopub.status.busy": "2026-06-15T21:38:10.526473Z", - "iopub.status.idle": "2026-06-15T21:38:12.653977Z", - "shell.execute_reply": "2026-06-15T21:38:12.653317Z" + "iopub.execute_input": "2026-10-05T23:11:30.734254Z", + "iopub.status.busy": "2026-10-05T23:11:30.734140Z", + "iopub.status.idle": "2026-10-05T23:11:32.271117Z", + "shell.execute_reply": "2026-10-05T23:11:32.270601Z" } }, "outputs": [], @@ -128,10 +129,10 @@ "id": "q1-list-top", "metadata": { "execution": { - "iopub.execute_input": "2026-06-15T21:38:12.655984Z", - "iopub.status.busy": "2026-06-15T21:38:12.655751Z", - "iopub.status.idle": "2026-06-15T21:38:12.788992Z", - "shell.execute_reply": "2026-06-15T21:38:12.788511Z" + "iopub.execute_input": "2026-10-05T23:11:32.272556Z", + "iopub.status.busy": "2026-10-05T23:11:32.272346Z", + "iopub.status.idle": "2026-10-05T23:11:32.382433Z", + "shell.execute_reply": "2026-10-05T23:11:32.381941Z" } }, "outputs": [ @@ -146,11 +147,10 @@ " v1/metadata/\n", " v1/models/\n", " v1/supplementary/\n", - " v1/test_html/\n", "\n", "Files:\n", " v1/ (0 bytes)\n", - " v1/README.md (3,547 bytes)\n" + " v1/README.md (3,609 bytes)\n" ] } ], @@ -173,10 +173,10 @@ "id": "q1-list-a549", "metadata": { "execution": { - "iopub.execute_input": "2026-06-15T21:38:12.790324Z", - "iopub.status.busy": "2026-06-15T21:38:12.790214Z", - "iopub.status.idle": "2026-06-15T21:38:12.870307Z", - "shell.execute_reply": "2026-06-15T21:38:12.869739Z" + "iopub.execute_input": "2026-10-05T23:11:32.383569Z", + "iopub.status.busy": "2026-10-05T23:11:32.383425Z", + "iopub.status.idle": "2026-10-05T23:11:32.461763Z", + "shell.execute_reply": "2026-10-05T23:11:32.461312Z" } }, "outputs": [ @@ -185,18 +185,18 @@ "output_type": "stream", "text": [ "v1/data/biohub-a549/test/\n", - " CAAX_DENV.ozx 13.6 GB\n", - " CAAX_ZIKV.ozx 13.5 GB\n", - " CAAX_mock.ozx 13.7 GB\n", - " H2B_DENV.ozx 13.3 GB\n", - " H2B_ZIKV.ozx 13.2 GB\n", - " H2B_mock.ozx 13.4 GB\n", - " SEC61B_DENV.ozx 10.3 GB\n", - " SEC61B_ZIKV.ozx 11.3 GB\n", - " SEC61B_mock.ozx 11.4 GB\n", - " TOMM20_DENV.ozx 11.4 GB\n", - " TOMM20_ZIKV.ozx 11.4 GB\n", - " TOMM20_mock.ozx 11.4 GB\n", + " CAAX_DENV.ozx 31.8 GB\n", + " CAAX_ZIKV.ozx 31.6 GB\n", + " CAAX_mock.ozx 32.0 GB\n", + " H2B_DENV.ozx 31.2 GB\n", + " H2B_ZIKV.ozx 30.9 GB\n", + " H2B_mock.ozx 31.4 GB\n", + " SEC61B_DENV.ozx 23.7 GB\n", + " SEC61B_ZIKV.ozx 25.9 GB\n", + " SEC61B_mock.ozx 26.1 GB\n", + " TOMM20_DENV.ozx 26.2 GB\n", + " TOMM20_ZIKV.ozx 26.0 GB\n", + " TOMM20_mock.ozx 26.1 GB\n", "v1/data/aics-hipsc/test/\n", " SEC61B.ozx 8.6 GB\n", " TOMM20.ozx 8.5 GB\n", @@ -222,7 +222,7 @@ "source": [ "### The `.ozx` format, and reading metadata without downloading\n", "\n", - "Each archive is a single `.ozx` file: a ZIP wrapping a [Zarr v3](https://zarr.readthedocs.io/) store in the [OME-NGFF](https://ngff.openmicroscopy.org/latest/) layout (iohub's RFC-9 *zipped OME-Zarr*). Because S3 serves HTTP range requests, we mount the remote ZIP with `fsspec` and read it with `zarr`, pulling only the shards we touch. A full archive is 8 to 13 GB; the cells below read its metadata, and later a few slices, fetching mere megabytes. (To work with a downloaded archive locally instead, `iohub.open_ome_zarr` reads `.ozx` directly.)\n", + "Each archive is a single `.ozx` file: a ZIP wrapping a [Zarr v3](https://zarr.readthedocs.io/) store in the [OME-NGFF](https://ngff.openmicroscopy.org/latest/) layout (iohub's RFC-9 *zipped OME-Zarr*). Because S3 serves HTTP range requests, we mount the remote ZIP with `fsspec` and read it with `zarr`, pulling only the shards we touch. A test archive is 8 to 32 GB; the cells below read its metadata, and later a few slices, fetching mere megabytes. (To work with a downloaded archive locally instead, `iohub.open_ome_zarr` reads `.ozx` directly.)\n", "\n", "Inside is an HCS plate: a single well of fields of view (FOVs), each a 5D `(T, C, Z, Y, X)` array of timepoints, channels, and a 3D volume. Every plate also carries provenance (`assembly_*` keys), channel names, voxel spacing, and per-channel normalization statistics that virtual-staining models train against. Let's open the A549 ER (SEC61B) mock archive and read all of it, streamed." ] @@ -233,10 +233,10 @@ "id": "q3-open", "metadata": { "execution": { - "iopub.execute_input": "2026-06-15T21:38:12.871423Z", - "iopub.status.busy": "2026-06-15T21:38:12.871307Z", - "iopub.status.idle": "2026-06-15T21:38:15.157993Z", - "shell.execute_reply": "2026-06-15T21:38:15.157445Z" + "iopub.execute_input": "2026-10-05T23:11:32.462853Z", + "iopub.status.busy": "2026-10-05T23:11:32.462738Z", + "iopub.status.idle": "2026-10-05T23:11:33.340106Z", + "shell.execute_reply": "2026-10-05T23:11:33.339455Z" } }, "outputs": [ @@ -244,7 +244,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "12 FOVs, each (10, 3, 48, 512, 512) (T, C, Z, Y, X), dtype float32\n" + "12 FOVs, each (10, 3, 48, 640, 960) (T, C, Z, Y, X), dtype float32\n" ] } ], @@ -264,10 +264,10 @@ "id": "q3-metadata", "metadata": { "execution": { - "iopub.execute_input": "2026-06-15T21:38:15.159583Z", - "iopub.status.busy": "2026-06-15T21:38:15.159393Z", - "iopub.status.idle": "2026-06-15T21:38:15.162636Z", - "shell.execute_reply": "2026-06-15T21:38:15.162221Z" + "iopub.execute_input": "2026-10-05T23:11:33.341332Z", + "iopub.status.busy": "2026-10-05T23:11:33.341125Z", + "iopub.status.idle": "2026-10-05T23:11:33.344386Z", + "shell.execute_reply": "2026-10-05T23:11:33.344017Z" } }, "outputs": [ @@ -279,14 +279,14 @@ " assembly_target: sec61b\n", " assembly_condition: mock\n", " assembly_split: test\n", - " assembly_center_crop_yx: [512, 512]\n", + " assembly_center_crop_yx: [640, 960]\n", " assembly_t_cap: 10\n", - " assembly_target_yx_pixel_size_um: None\n", + " assembly_target_yx_pixel_size_um: 0.1494\n", "\n", "=== Per-channel normalization (dataset percentiles) ===\n", - " Phase3D p1=-0.289 p99=0.319 mean=0.000\n", - " Brightfield p1=1090.000 p99=2955.000 mean=1711.493\n", - " Structure p1=27.974 p99=313.378 mean=116.020\n" + " Phase3D p1=-0.288 p99=0.316 mean=0.000\n", + " Brightfield p1=1060.000 p99=2923.000 mean=1682.994\n", + " Structure p1=100.149 p99=175.793 mean=113.630\n" ] } ], @@ -317,10 +317,10 @@ "id": "q3-channels", "metadata": { "execution": { - "iopub.execute_input": "2026-06-15T21:38:15.163682Z", - "iopub.status.busy": "2026-06-15T21:38:15.163576Z", - "iopub.status.idle": "2026-06-15T21:38:15.166488Z", - "shell.execute_reply": "2026-06-15T21:38:15.166097Z" + "iopub.execute_input": "2026-10-05T23:11:33.345296Z", + "iopub.status.busy": "2026-10-05T23:11:33.345189Z", + "iopub.status.idle": "2026-10-05T23:11:33.348103Z", + "shell.execute_reply": "2026-10-05T23:11:33.347799Z" } }, "outputs": [ @@ -370,10 +370,10 @@ "id": "q4-load", "metadata": { "execution": { - "iopub.execute_input": "2026-06-15T21:38:15.167626Z", - "iopub.status.busy": "2026-06-15T21:38:15.167520Z", - "iopub.status.idle": "2026-06-15T21:38:15.184553Z", - "shell.execute_reply": "2026-06-15T21:38:15.184110Z" + "iopub.execute_input": "2026-10-05T23:11:33.349224Z", + "iopub.status.busy": "2026-10-05T23:11:33.349120Z", + "iopub.status.idle": "2026-10-05T23:11:33.363836Z", + "shell.execute_reply": "2026-10-05T23:11:33.363411Z" } }, "outputs": [], @@ -497,16 +497,16 @@ "id": "q4-side-by-side", "metadata": { "execution": { - "iopub.execute_input": "2026-06-15T21:38:15.185734Z", - "iopub.status.busy": "2026-06-15T21:38:15.185575Z", - "iopub.status.idle": "2026-06-15T21:39:25.721694Z", - "shell.execute_reply": "2026-06-15T21:39:25.721042Z" + "iopub.execute_input": "2026-10-05T23:11:33.364859Z", + "iopub.status.busy": "2026-10-05T23:11:33.364682Z", + "iopub.status.idle": "2026-10-05T23:12:25.807765Z", + "shell.execute_reply": "2026-10-05T23:12:25.807324Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -516,7 +516,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -526,7 +526,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -536,7 +536,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -564,7 +564,7 @@ "\n", "- **Run the benchmark.** The dataset ships with eval configs and a pipeline (`dynacell evaluate`, `dynacell evaluate-grouped`) that scores predictions on pixel similarity (Spectral PCC, SSIM) and cell-level features (DINOv3, DynaCLR) for each (model, organelle, condition).\n", "- **Train and test across the axes.** Hold out a cell type or a condition; the drop in score is the generalization gap. Joint training across A549 and hiPSC, and across organelles, is one lever; domain adaptation from unpaired brightfield is another.\n", - "- **Start from a baseline.** Pre-trained VSCyto3D, FNet3D, UNeXt2, and CELL-Diff weights live under `v1/models/`.\n", + "- **Start from a baseline.** Trained FNet3D, UNeXt2, VSCyto3D, UNetViT3D, Pix2Pix3D, and CELL-Diff weights live under `v1/models/`; its `README.md` explains the layout and how to load them.\n", "\n", "Code and configs: https://github.com/mehta-lab/VisCy/tree/main/applications/dynacell" ] diff --git a/applications/dynacell/pyproject.toml b/applications/dynacell/pyproject.toml index 77ebbecc6..c99cccb26 100644 --- a/applications/dynacell/pyproject.toml +++ b/applications/dynacell/pyproject.toml @@ -39,12 +39,41 @@ dependencies = [ "viscy-transforms", "viscy-utils", ] +# Croissant 1.1 RAI metadata authoring/validation for the open-data release. +optional-dependencies.croissant = [ + "mlcroissant>=1.1", +] +# Open-data packaging/upload (dynacell.distribution): verify.py reads S3 via +# boto3; sync.py shells out to the AWS CLI (installed out of band). +optional-dependencies.distribution = [ + "boto3", +] optional-dependencies.eval = [ "accelerate>=1.13", "aicsmlsegment", "aicssegmentation", - "cellpose", - "cubic==0.7", + # cpdino (Cellpose-DINO ViT-L) instance segmentation requires cellpose>=4.2 + # (adds the DINO backbones + `pretrained_model="cpdino"`) and its dinov3 backbone. + "cellpose>=4.2", + # cubic 0.8.0a2 added device-resident segment_cellpose for all Cellpose v4 + # models (SAM + DINO). v0.9.0a1 is the metric-correctness release (PR #53, + # "repository-wide bug sweep"): `ssim` now honours `normalize` instead of + # silently dropping it into **kwargs, `scale_invariant` raises when combined + # with `normalize`/`normalization` rather than returning a quietly wrong + # number, and the FSC/spectral, MicroSSIM, MS-SSIM, feature (KID/FID) and + # average_precision modules were rewritten. Every pixel/feature metric in the + # benchmark can move across this pin, so a bump needs either a full re-eval or + # a measured entry in dynacell.evaluation.provenance.CUBIC_VERSIONS_EQUIVALENT_TO + # -- do not bump it casually. Tag, not a bare commit. v0.9.0a2 rewrites only the + # MicroSSIM RI-factor fit: chunked float64 reduction (peak 40.5 -> 12.9 GB on + # 576x640x960 float32) and a ValueError on empty input; measured equivalent. + # v0.9.0a3 fixes single-image FSC/FRC splitting (binomial path, sampling-floor + # warning); production's two-image FSC/FRC is untouched -- measured exact. + # v0.9.0a4 adds device-agnostic ER/mitochondria workflows and faster metric + # kernels. Runtime workflow capabilities are checked separately from cache + # equivalence in dynacell.evaluation.provenance / segmentation. + "cubic @ git+https://github.com/alxndrkalinin/cubic.git@v0.9.0a4", + "dinov3 @ git+https://github.com/facebookresearch/dinov3", "dynaclr", "hydra-core>=1.2", "iohub>=0.3.6", @@ -76,9 +105,14 @@ optional-dependencies.eval_gpu = [ "cucim-cu13", "cupy-cuda13x", ] +# Dataset assembly / authoring library (dynacell.preprocess): assemble->cubic, +# selection->waveorder, segmentation->cellpose (cellpose imported lazily). optional-dependencies.preprocess = [ + "cellpose>=4.2", + "cubic @ git+https://github.com/alxndrkalinin/cubic.git@v0.9.0a4", "iohub>=0.3.6", "tqdm", + "waveorder", ] optional-dependencies.report = [ "hydra-core>=1.2", diff --git a/applications/dynacell/src/README.md b/applications/dynacell/src/README.md new file mode 100644 index 000000000..885a53238 --- /dev/null +++ b/applications/dynacell/src/README.md @@ -0,0 +1,14 @@ +# src + +Source root for the installable `dynacell` package (the sole package in this application's `src/` layout, per +`pyproject.toml`). + +## Contents + +- **[dynacell/](dynacell/README.md)** — the DynaCell Python package: LightningModules (engine), data schemas + + manifest resolver, the evaluation pipeline, reporting, preprocessing, and the bundled dataset registry. + +## Navigation + +- Up: [applications/dynacell](../README.md) +- Subdirectories: [dynacell/](dynacell/README.md) diff --git a/applications/dynacell/src/dynacell/README.md b/applications/dynacell/src/dynacell/README.md new file mode 100644 index 000000000..eebd7640b --- /dev/null +++ b/applications/dynacell/src/dynacell/README.md @@ -0,0 +1,43 @@ +# dynacell (package) + +The installable `dynacell` package: virtual-staining LightningModules, the manifest-driven data layer, the +three-tier evaluation pipeline, reporting, and preprocessing. Consumes the `viscy-*` workspace packages +(`viscy_data`, `viscy_models`, `viscy_transforms`, `viscy_utils`); never imports from sibling applications. + +## Top-level modules + +- `__init__.py` — lazily exposes the three engines (`DynacellUNet`, `DynacellFlowMatching`, `DynacellGAN`) to + avoid pulling heavy training deps on import. +- `__main__.py` — CLI entry point. Routes Lightning subcommands (`fit`/`validate`/`predict`) to + `viscy_utils.cli.main()` and Hydra subcommands (`evaluate`, `evaluate-grouped`, `precompute-gt`, `report`) to + their entry points; also injects the eval Hydra searchpaths and shared HF cache on a repo checkout. +- `engine.py` — the LightningModules: `DynacellUNet` (regression), `DynacellFlowMatching` (CELL-Diff), + `DynacellGAN` (pix2pix3d adversarial). +- `celldiff_wrapper.py` — `CELLDiff3DVS`, wrapping `viscy_models.celldiff.CELLDiffNet` with flow-matching + transport (loss + ODE-based generation). +- `_compose_hook.py` — composition-time resolver spliced into `viscy_utils.compose`; reads + `benchmark.dataset_ref` and fills concrete `data_path`/channels from the manifest so benchmark leaves run + standalone. + +## Subpackages + +- **[data/](data/README.md)** — dataset schemas (collections, manifests, splits) and the manifest-root resolver + that turns a `DatasetRef` into concrete paths + channel names. +- **[evaluation/](evaluation/README.md)** — the three-tier metric pipeline: segmentation, pixel/mask/feature + metrics, deep-feature extractors, artifact cache, focus-aware 2D projection, runtime parallelism. +- **[_manifests/](_manifests/README.md)** — bundled dataset registry (A549-Mantis per-organelle/condition + + AICS iPSC manifests), the default source for the resolver. +- `reporting/` — `dynacell report`: aggregate eval CSV/NPY into paper tables (`tables.py`) and comparison + figures (`figures.py`); Hydra schema in `_configs/`. +- `preprocess/` — reusable dataset-preprocessing helpers (`load_preprocess_config`, `rewrite_zarr`). + +## Conventions + +Code↔paper name translation, training-data pooling, and prediction/eval-dir naming live in the application +[CLAUDE.md](../../CLAUDE.md). The evaluation subpackage carries its own [CLAUDE.md](evaluation/CLAUDE.md) +covering the mandatory `cubic` GPU-dispatch pattern. + +## Navigation + +- Up: [src](../README.md) +- Subdirectories: [data/](data/README.md), [evaluation/](evaluation/README.md), [_manifests/](_manifests/README.md) diff --git a/applications/dynacell/src/dynacell/__main__.py b/applications/dynacell/src/dynacell/__main__.py index a357c4dbe..164bca3ee 100644 --- a/applications/dynacell/src/dynacell/__main__.py +++ b/applications/dynacell/src/dynacell/__main__.py @@ -21,9 +21,24 @@ "evaluate": ("dynacell.evaluation.pipeline", "evaluate_model", "eval"), "evaluate-grouped": ("dynacell.evaluation.pipeline", "evaluate_model_grouped", "eval"), "precompute-gt": ("dynacell.evaluation.precompute_cli", "precompute_gt", "eval"), + "backfill-pixel-scalings": ( + "dynacell.evaluation.pixel_scaling_backfill", + "backfill_pixel_scalings", + "eval", + ), "report": ("dynacell.reporting.cli", "generate_report", "report"), } +# Argparse (non-Hydra) subcommands. These were written against the +# ``dynacell-paper`` top-level dispatcher, which Phase 13 retired when this +# package took over the pipeline end to end; routing them here restores the +# release workflow (`distribute pack` / `sync` / `verify-public`, `croissant +# from-release`) without reviving a second console script. +_ARGPARSE_COMMANDS: dict[str, tuple[str, str]] = { + "croissant": ("dynacell.croissant.cli", "croissant"), + "distribute": ("dynacell.distribution.cli", "distribution"), +} + # HPC-specific config groups (target, feature_extractor/dynaclr, benchmark eval # leaves) live outside the Python package so the wheel ships only schema + path- # free references. Editable installs / repo checkouts expose these through @@ -115,6 +130,19 @@ def main_cli(): early_apply_env_caps() + if len(sys.argv) >= 2 and sys.argv[1] in _ARGPARSE_COMMANDS: + command = sys.argv[1] + module_path, extra = _ARGPARSE_COMMANDS[command] + # Each module's argparse reads sys.argv[1:], so strip our own token. + sys.argv = [f"{sys.argv[0]} {command}"] + sys.argv[2:] + try: + module = importlib.import_module(module_path) + except ModuleNotFoundError as e: + print(f"Missing dependencies for 'dynacell {command}': {e}\nInstall with: pip install 'dynacell[{extra}]'") + raise SystemExit(1) from e + module.main() + return + if len(sys.argv) >= 2 and sys.argv[1] in _HYDRA_COMMANDS: command = sys.argv[1] module_path, func_name, extra = _HYDRA_COMMANDS[command] diff --git a/applications/dynacell/src/dynacell/_compose_hook.py b/applications/dynacell/src/dynacell/_compose_hook.py index 53a6cc402..0d12537b4 100644 --- a/applications/dynacell/src/dynacell/_compose_hook.py +++ b/applications/dynacell/src/dynacell/_compose_hook.py @@ -43,7 +43,18 @@ def _splice_resolved(composed: dict, resolved: ResolvedDataset, mode: str, ref: the resolved data fields. A full ``dataset_ref`` is the single source of truth — composed fragments must not co-declare ``data_path``, ``source_channel``, or ``target_channel``. + + Also raises for a train-less (evaluation-only) dataset in any mode but + ``predict``: ``resolved_values`` is built eagerly, so a ``None`` train + store would be stringified to ``"None"`` and fail deep inside iohub + instead of here. """ + if mode != "predict" and resolved.data_path_train is None: + raise ValueError( + f"benchmark.dataset_ref={{dataset: {ref.dataset}, target: {ref.target}}} resolves to a " + f"dataset with no train store, but the Lightning mode is {mode!r}; this dataset is " + "evaluation-only." + ) out = copy.deepcopy(composed) data = out.setdefault("data", {}) init_args = data.setdefault("init_args", {}) diff --git a/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/membrane_ipsc_v1.yaml b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/membrane_ipsc_v1.yaml new file mode 100644 index 000000000..3cb4f067b --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/membrane_ipsc_v1.yaml @@ -0,0 +1,658 @@ +name: membrane_ipsc_v1 +description: Frozen benchmark collection for 'aics-hipsc' target 'membrane'. Channels + and FOV membership captured from the live train/test zarr stores at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-27T12:03:25.118506+00:00' + created_by: Alex Kalinin +experiments: +- name: membrane_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Membrane + organelle: membrane + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: membrane_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Membrane + organelle: membrane + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +train_fovs: +- membrane_hipsc_train/4/10615/1304 +- membrane_hipsc_train/4/10625/1347 +- membrane_hipsc_train/4/10900/1427 +- membrane_hipsc_train/4/10904/1436 +- membrane_hipsc_train/4/11384/1404 +- membrane_hipsc_train/4/11478/1468 +- membrane_hipsc_train/4/11490/1466 +- membrane_hipsc_train/4/11492/1467 +- membrane_hipsc_train/4/11573/1414 +- membrane_hipsc_train/4/136707/16750 +- membrane_hipsc_train/4/136710/15363 +- membrane_hipsc_train/4/136721/16107 +- membrane_hipsc_train/4/136725/15834 +- membrane_hipsc_train/4/13974/1528 +- membrane_hipsc_train/4/14646/1871 +- membrane_hipsc_train/4/14740/1745 +- membrane_hipsc_train/4/14742/1791 +- membrane_hipsc_train/4/14754/1781 +- membrane_hipsc_train/4/1493/268 +- membrane_hipsc_train/4/1508/255 +- membrane_hipsc_train/4/16278/2186 +- membrane_hipsc_train/4/16376/2374 +- membrane_hipsc_train/4/16468/2321 +- membrane_hipsc_train/4/16469/2337 +- membrane_hipsc_train/4/16469/2339 +- membrane_hipsc_train/4/16469/2345 +- membrane_hipsc_train/4/16471/2265 +- membrane_hipsc_train/4/16472/2312 +- membrane_hipsc_train/4/16951/2459 +- membrane_hipsc_train/4/16951/2480 +- membrane_hipsc_train/4/16952/2494 +- membrane_hipsc_train/4/17333/2710 +- membrane_hipsc_train/4/17348/16148 +- membrane_hipsc_train/4/17525/2811 +- membrane_hipsc_train/4/17526/2752 +- membrane_hipsc_train/4/17536/2773 +- membrane_hipsc_train/4/18020/1618 +- membrane_hipsc_train/4/18020/1625 +- membrane_hipsc_train/4/18020/1638 +- membrane_hipsc_train/4/18487/1811 +- membrane_hipsc_train/4/19351/1905 +- membrane_hipsc_train/4/19543/2105 +- membrane_hipsc_train/4/19554/2020 +- membrane_hipsc_train/4/19556/2089 +- membrane_hipsc_train/4/20416/2223 +- membrane_hipsc_train/4/20596/2406 +- membrane_hipsc_train/4/20597/2395 +- membrane_hipsc_train/4/20597/2401 +- membrane_hipsc_train/4/20599/2373 +- membrane_hipsc_train/4/21077/2254 +- membrane_hipsc_train/4/21089/2293 +- membrane_hipsc_train/4/21556/2491 +- membrane_hipsc_train/4/21557/2483 +- membrane_hipsc_train/4/21557/2527 +- membrane_hipsc_train/4/21653/2547 +- membrane_hipsc_train/4/21860/15671 +- membrane_hipsc_train/4/21940/2736 +- membrane_hipsc_train/4/21943/2717 +- membrane_hipsc_train/4/21953/2739 +- membrane_hipsc_train/4/22133/2826 +- membrane_hipsc_train/4/22136/2827 +- membrane_hipsc_train/4/22339/3095 +- membrane_hipsc_train/4/22340/3097 +- membrane_hipsc_train/4/22612/2915 +- membrane_hipsc_train/4/22614/2923 +- membrane_hipsc_train/4/22615/2978 +- membrane_hipsc_train/4/22624/2909 +- membrane_hipsc_train/4/22709/3070 +- membrane_hipsc_train/4/22712/3090 +- membrane_hipsc_train/4/22913/3301 +- membrane_hipsc_train/4/22914/3289 +- membrane_hipsc_train/4/23380/3237 +- membrane_hipsc_train/4/23392/3212 +- membrane_hipsc_train/4/23395/3223 +- membrane_hipsc_train/4/23574/3492 +- membrane_hipsc_train/4/23764/3409 +- membrane_hipsc_train/4/24152/3567 +- membrane_hipsc_train/4/24724/3661 +- membrane_hipsc_train/4/24727/3659 +- membrane_hipsc_train/4/24928/3585 +- membrane_hipsc_train/4/25784/3851 +- membrane_hipsc_train/4/27800/2883 +- membrane_hipsc_train/4/27896/2943 +- membrane_hipsc_train/4/27992/3020 +- membrane_hipsc_train/4/28084/3214 +- membrane_hipsc_train/4/28084/3270 +- membrane_hipsc_train/4/28087/3266 +- membrane_hipsc_train/4/28756/3381 +- membrane_hipsc_train/4/28759/3393 +- membrane_hipsc_train/4/29045/3764 +- membrane_hipsc_train/4/29060/3753 +- membrane_hipsc_train/4/29143/3667 +- membrane_hipsc_train/4/29155/3710 +- membrane_hipsc_train/4/2932/230 +- membrane_hipsc_train/4/29333/3908 +- membrane_hipsc_train/4/2945/173 +- membrane_hipsc_train/4/30292/14379 +- membrane_hipsc_train/4/30293/3905 +- membrane_hipsc_train/4/30308/3869 +- membrane_hipsc_train/4/30388/16862 +- membrane_hipsc_train/4/30389/15342 +- membrane_hipsc_train/4/30392/16741 +- membrane_hipsc_train/4/31732/17059 +- membrane_hipsc_train/4/31744/16779 +- membrane_hipsc_train/4/31841/3962 +- membrane_hipsc_train/4/31939/3975 +- membrane_hipsc_train/4/32024/4077 +- membrane_hipsc_train/4/32033/4111 +- membrane_hipsc_train/4/32033/4121 +- membrane_hipsc_train/4/32035/4099 +- membrane_hipsc_train/4/33077/4379 +- membrane_hipsc_train/4/33572/4229 +- membrane_hipsc_train/4/33942/15337 +- membrane_hipsc_train/4/33942/16205 +- membrane_hipsc_train/4/33943/17061 +- membrane_hipsc_train/4/33953/16561 +- membrane_hipsc_train/4/33955/16023 +- membrane_hipsc_train/4/34038/4363 +- membrane_hipsc_train/4/34808/4417 +- membrane_hipsc_train/4/35000/4274 +- membrane_hipsc_train/4/35284/4472 +- membrane_hipsc_train/4/35287/4460 +- membrane_hipsc_train/4/35479/4551 +- membrane_hipsc_train/4/35489/4583 +- membrane_hipsc_train/4/36449/15327 +- membrane_hipsc_train/4/36544/4909 +- membrane_hipsc_train/4/36544/4931 +- membrane_hipsc_train/4/36628/4907 +- membrane_hipsc_train/4/36836/4996 +- membrane_hipsc_train/4/37591/5133 +- membrane_hipsc_train/4/37603/5147 +- membrane_hipsc_train/4/37972/5388 +- membrane_hipsc_train/4/37988/5373 +- membrane_hipsc_train/4/40084/5359 +- membrane_hipsc_train/4/40086/5362 +- membrane_hipsc_train/4/40376/4584 +- membrane_hipsc_train/4/40385/4614 +- membrane_hipsc_train/4/40386/4613 +- membrane_hipsc_train/4/40387/4586 +- membrane_hipsc_train/4/40483/4619 +- membrane_hipsc_train/4/40483/4621 +- membrane_hipsc_train/4/40960/4654 +- membrane_hipsc_train/4/41044/4851 +- membrane_hipsc_train/4/41047/4885 +- membrane_hipsc_train/4/41237/4861 +- membrane_hipsc_train/4/41249/4835 +- membrane_hipsc_train/4/41912/5074 +- membrane_hipsc_train/4/5143/954 +- membrane_hipsc_train/4/5236/869 +- membrane_hipsc_train/4/5238/875 +- membrane_hipsc_train/4/6485/1018 +- membrane_hipsc_train/4/6486/992 +- membrane_hipsc_train/4/6497/1003 +- membrane_hipsc_train/4/6775/1203 +- membrane_hipsc_train/4/6775/1226 +- membrane_hipsc_train/4/6775/1236 +- membrane_hipsc_train/4/7156/1124 +- membrane_hipsc_train/4/7349/1355 +- membrane_hipsc_train/4/7650/1278 +- membrane_hipsc_train/4/8214/878 +- membrane_hipsc_train/4/8214/879 +- membrane_hipsc_train/4/8228/898 +- membrane_hipsc_train/4/8695/1215 +- membrane_hipsc_train/4/88267/15294 +- membrane_hipsc_train/4/89048/356 +- membrane_hipsc_train/4/8982/1171 +- membrane_hipsc_train/4/90088/415 +- membrane_hipsc_train/4/90858/15658 +- membrane_hipsc_train/4/90858/16534 +- membrane_hipsc_train/4/91144/102 +- membrane_hipsc_train/4/91924/458 +- membrane_hipsc_train/4/93448/596 +- membrane_hipsc_train/4/94312/684 +- membrane_hipsc_train/4/95752/811 +- membrane_hipsc_train/4/95753/737 +- membrane_hipsc_train/4/95753/872 +- membrane_hipsc_train/41/43638/5246 +- membrane_hipsc_train/41/43639/5265 +- membrane_hipsc_train/41/43732/16519 +- membrane_hipsc_train/41/45556/5706 +- membrane_hipsc_train/41/45556/5734 +- membrane_hipsc_train/41/45559/5714 +- membrane_hipsc_train/41/48436/5507 +- membrane_hipsc_train/41/48534/5575 +- membrane_hipsc_train/41/48535/5623 +- membrane_hipsc_train/41/48548/5574 +- membrane_hipsc_train/41/48548/5589 +- membrane_hipsc_train/41/49204/5661 +- membrane_hipsc_train/41/49220/5671 +- membrane_hipsc_train/41/49698/5819 +- membrane_hipsc_train/41/49972/5933 +- membrane_hipsc_train/41/49973/5960 +- membrane_hipsc_train/41/50263/6077 +- membrane_hipsc_train/41/50263/6082 +- membrane_hipsc_train/41/50356/15510 +- membrane_hipsc_train/41/50356/15578 +- membrane_hipsc_train/41/50359/15457 +- membrane_hipsc_train/41/50548/6024 +- membrane_hipsc_train/41/50551/6022 +- membrane_hipsc_train/41/53044/15243 +- membrane_hipsc_train/41/53046/16965 +- membrane_hipsc_train/41/53428/6238 +- membrane_hipsc_train/41/53524/15636 +- membrane_hipsc_train/41/53538/15395 +- membrane_hipsc_train/41/53731/15920 +- membrane_hipsc_train/41/55156/6355 +- membrane_hipsc_train/41/55156/6358 +- membrane_hipsc_train/41/55158/6324 +- membrane_hipsc_train/41/55158/6353 +- membrane_hipsc_train/41/55253/6499 +- membrane_hipsc_train/41/55256/6482 +- membrane_hipsc_train/41/55351/6419 +- membrane_hipsc_train/41/55363/6362 +- membrane_hipsc_train/41/55925/6584 +- membrane_hipsc_train/41/56406/6643 +- membrane_hipsc_train/41/56416/6614 +- membrane_hipsc_train/41/56418/6626 +- membrane_hipsc_train/41/56419/6630 +- membrane_hipsc_train/41/56596/6678 +- membrane_hipsc_train/41/56896/7720 +- membrane_hipsc_train/41/57364/6456 +- membrane_hipsc_train/41/57365/6428 +- membrane_hipsc_train/41/57367/6430 +- membrane_hipsc_train/41/57464/6544 +- membrane_hipsc_train/41/57472/6556 +- membrane_hipsc_train/41/57472/6565 +- membrane_hipsc_train/41/58134/6821 +- membrane_hipsc_train/41/58326/6840 +- membrane_hipsc_train/41/58420/6971 +- membrane_hipsc_train/41/58423/6963 +- membrane_hipsc_train/41/58518/6786 +- membrane_hipsc_train/41/59285/7118 +- membrane_hipsc_train/41/59285/7124 +- membrane_hipsc_train/41/59298/7175 +- membrane_hipsc_train/41/59380/7015 +- membrane_hipsc_train/41/59479/7188 +- membrane_hipsc_train/41/59479/7200 +- membrane_hipsc_train/41/59480/7179 +- membrane_hipsc_train/41/60548/7475 +- membrane_hipsc_train/41/60632/7345 +- membrane_hipsc_train/41/60726/7399 +- membrane_hipsc_train/41/60737/7332 +- membrane_hipsc_train/41/60738/7414 +- membrane_hipsc_train/41/62740/7068 +- membrane_hipsc_train/41/62932/6916 +- membrane_hipsc_train/41/63508/7389 +- membrane_hipsc_train/41/63523/7383 +- membrane_hipsc_train/41/63608/7462 +- membrane_hipsc_train/41/63608/7464 +- membrane_hipsc_train/41/63620/7451 +- membrane_hipsc_train/41/63701/7283 +- membrane_hipsc_train/41/63713/7256 +- membrane_hipsc_train/41/66292/7775 +- membrane_hipsc_train/41/66292/7782 +- membrane_hipsc_train/41/66292/7796 +- membrane_hipsc_train/41/66296/7788 +- membrane_hipsc_train/41/67157/7690 +- membrane_hipsc_train/41/67168/7678 +- membrane_hipsc_train/41/68131/7834 +- membrane_hipsc_train/41/68503/9206 +- membrane_hipsc_train/41/68504/9176 +- membrane_hipsc_train/41/68504/9197 +- membrane_hipsc_train/41/68512/9188 +- membrane_hipsc_train/41/68512/9207 +- membrane_hipsc_train/41/68512/9212 +- membrane_hipsc_train/41/68708/9065 +- membrane_hipsc_train/41/68788/9030 +- membrane_hipsc_train/41/68800/9019 +- membrane_hipsc_train/41/69472/9285 +- membrane_hipsc_train/41/69473/9279 +- membrane_hipsc_train/41/69474/9306 +- membrane_hipsc_train/41/70052/15689 +- membrane_hipsc_train/41/70231/9525 +- membrane_hipsc_train/41/70232/9551 +- membrane_hipsc_train/41/72244/8037 +- membrane_hipsc_train/41/72244/8074 +- membrane_hipsc_train/41/72256/8049 +- membrane_hipsc_train/41/72260/8085 +- membrane_hipsc_train/41/72342/7994 +- membrane_hipsc_train/41/72356/7962 +- membrane_hipsc_train/41/72628/8109 +- membrane_hipsc_train/41/72629/8086 +- membrane_hipsc_train/41/72630/8119 +- membrane_hipsc_train/41/72631/8095 +- membrane_hipsc_train/41/72725/8151 +- membrane_hipsc_train/41/72726/8128 +- membrane_hipsc_train/41/72834/8288 +- membrane_hipsc_train/41/73300/8255 +- membrane_hipsc_train/41/73396/8265 +- membrane_hipsc_train/41/73397/8271 +- membrane_hipsc_train/41/73398/8307 +- membrane_hipsc_train/41/73495/8186 +- membrane_hipsc_train/41/73507/8203 +- membrane_hipsc_train/41/73685/8634 +- membrane_hipsc_train/41/73687/8628 +- membrane_hipsc_train/41/73700/8663 +- membrane_hipsc_train/41/73782/8525 +- membrane_hipsc_train/41/73782/8576 +- membrane_hipsc_train/41/73783/8530 +- membrane_hipsc_train/41/73784/8543 +- membrane_hipsc_train/41/73879/15995 +- membrane_hipsc_train/41/73975/15832 +- membrane_hipsc_train/41/74165/8821 +- membrane_hipsc_train/41/74168/8793 +- membrane_hipsc_train/41/74260/8727 +- membrane_hipsc_train/41/74273/8721 +- membrane_hipsc_train/41/74371/8941 +- membrane_hipsc_train/41/74371/8978 +- membrane_hipsc_train/41/75042/7915 +- membrane_hipsc_train/41/75124/16978 +- membrane_hipsc_train/41/75125/16693 +- membrane_hipsc_train/41/75512/7872 +- membrane_hipsc_train/41/75796/7941 +- membrane_hipsc_train/41/75799/7953 +- membrane_hipsc_train/41/76000/8244 +- membrane_hipsc_train/41/77250/8868 +- membrane_hipsc_train/41/77333/9094 +- membrane_hipsc_train/42/106420/10373 +- membrane_hipsc_train/42/106421/10380 +- membrane_hipsc_train/42/106422/10368 +- membrane_hipsc_train/42/106516/10272 +- membrane_hipsc_train/42/106518/10239 +- membrane_hipsc_train/42/106520/10262 +- membrane_hipsc_train/42/106915/10747 +- membrane_hipsc_train/42/106996/10652 +- membrane_hipsc_train/42/106998/10641 +- membrane_hipsc_train/42/107480/10815 +- membrane_hipsc_train/42/107480/10822 +- membrane_hipsc_train/42/107572/12022 +- membrane_hipsc_train/42/107574/11982 +- membrane_hipsc_train/42/107574/12039 +- membrane_hipsc_train/42/107682/11895 +- membrane_hipsc_train/42/107682/11898 +- membrane_hipsc_train/42/107684/11928 +- membrane_hipsc_train/42/107956/11969 +- membrane_hipsc_train/42/107956/11981 +- membrane_hipsc_train/42/107958/11911 +- membrane_hipsc_train/42/107959/12029 +- membrane_hipsc_train/42/107972/11941 +- membrane_hipsc_train/42/108148/15673 +- membrane_hipsc_train/42/108149/12190 +- membrane_hipsc_train/42/108246/11135 +- membrane_hipsc_train/42/108248/16355 +- membrane_hipsc_train/42/108824/15581 +- membrane_hipsc_train/42/108833/15155 +- membrane_hipsc_train/42/110548/10130 +- membrane_hipsc_train/42/110552/10154 +- membrane_hipsc_train/42/110552/10175 +- membrane_hipsc_train/42/110645/10108 +- membrane_hipsc_train/42/110646/10124 +- membrane_hipsc_train/42/110660/10091 +- membrane_hipsc_train/42/110947/10199 +- membrane_hipsc_train/42/111125/10242 +- membrane_hipsc_train/42/111413/10485 +- membrane_hipsc_train/42/111415/10486 +- membrane_hipsc_train/42/111426/10473 +- membrane_hipsc_train/42/111892/10724 +- membrane_hipsc_train/42/112084/15061 +- membrane_hipsc_train/42/112085/16293 +- membrane_hipsc_train/42/112280/15454 +- membrane_hipsc_train/42/112565/10904 +- membrane_hipsc_train/42/112758/16064 +- membrane_hipsc_train/42/112772/14973 +- membrane_hipsc_train/42/113432/11852 +- membrane_hipsc_train/42/113634/10939 +- membrane_hipsc_train/42/113921/11053 +- membrane_hipsc_train/42/114209/10977 +- membrane_hipsc_train/42/114212/10981 +- membrane_hipsc_train/42/114787/11121 +- membrane_hipsc_train/42/114788/11097 +- membrane_hipsc_train/42/114965/11232 +- membrane_hipsc_train/42/114965/11269 +- membrane_hipsc_train/42/114979/11222 +- membrane_hipsc_train/42/115160/12126 +- membrane_hipsc_train/42/115169/16617 +- membrane_hipsc_train/42/115349/11410 +- membrane_hipsc_train/42/115541/15346 +- membrane_hipsc_train/42/115542/16879 +- membrane_hipsc_train/42/115552/15185 +- membrane_hipsc_train/42/115554/15716 +- membrane_hipsc_train/42/115555/16425 +- membrane_hipsc_train/42/115556/15703 +- membrane_hipsc_train/42/115831/11479 +- membrane_hipsc_train/42/116034/11497 +- membrane_hipsc_train/42/116309/11595 +- membrane_hipsc_train/42/116324/11616 +- membrane_hipsc_train/42/116608/10515 +- membrane_hipsc_train/42/116608/10614 +- membrane_hipsc_train/42/116887/10440 +- membrane_hipsc_train/42/116897/10412 +- membrane_hipsc_train/42/116900/10422 +- membrane_hipsc_train/42/117173/10673 +- membrane_hipsc_train/42/117186/10657 +- membrane_hipsc_train/42/117557/11347 +- membrane_hipsc_train/42/117559/11367 +- membrane_hipsc_train/42/117572/11385 +- membrane_hipsc_train/42/117847/11299 +- membrane_hipsc_train/42/118420/11731 +- membrane_hipsc_train/42/118423/11658 +- membrane_hipsc_train/42/118712/11569 +- membrane_hipsc_train/42/118806/11804 +- membrane_hipsc_train/42/118808/11800 +- membrane_hipsc_train/42/121791/16666 +- membrane_hipsc_train/42/121793/15852 +- membrane_hipsc_train/42/121806/15946 +- membrane_hipsc_train/42/123328/15550 +- membrane_hipsc_train/42/123328/17092 +- membrane_hipsc_train/42/123714/16851 +- membrane_hipsc_train/42/123903/15431 +- membrane_hipsc_train/42/124002/16132 +- membrane_hipsc_train/42/124014/16885 +- membrane_hipsc_train/42/124205/15565 +- membrane_hipsc_train/42/124287/15382 +- membrane_hipsc_train/42/124290/15483 +- membrane_hipsc_train/42/124291/15731 +- membrane_hipsc_train/42/124299/16712 +- membrane_hipsc_train/42/124301/15843 +- membrane_hipsc_train/42/127171/12333 +- membrane_hipsc_train/42/127647/12252 +- membrane_hipsc_train/42/127648/12223 +- membrane_hipsc_train/42/127649/12208 +- membrane_hipsc_train/42/127650/12238 +- membrane_hipsc_train/42/127650/12256 +- membrane_hipsc_train/42/127651/12217 +- membrane_hipsc_train/42/127651/12239 +- membrane_hipsc_train/42/127852/12320 +- membrane_hipsc_train/42/127935/12457 +- membrane_hipsc_train/42/127947/12485 +- membrane_hipsc_train/42/128416/12512 +- membrane_hipsc_train/42/128514/12657 +- membrane_hipsc_train/42/128514/12667 +- membrane_hipsc_train/42/128525/12654 +- membrane_hipsc_train/42/128715/12598 +- membrane_hipsc_train/42/128718/12626 +- membrane_hipsc_train/42/128719/12625 +- membrane_hipsc_train/42/129473/12830 +- membrane_hipsc_train/42/129473/12852 +- membrane_hipsc_train/42/129571/12811 +- membrane_hipsc_train/42/129583/12802 +- membrane_hipsc_train/42/129774/12715 +- membrane_hipsc_train/42/129855/12931 +- membrane_hipsc_train/42/130155/13043 +- membrane_hipsc_train/42/130527/12960 +- membrane_hipsc_train/42/130625/16186 +- membrane_hipsc_train/42/130707/13231 +- membrane_hipsc_train/42/130722/17097 +- membrane_hipsc_train/42/132173/13409 +- membrane_hipsc_train/42/132175/13365 +- membrane_hipsc_train/42/132653/13278 +- membrane_hipsc_train/42/132831/13415 +- membrane_hipsc_train/42/132844/13432 +- membrane_hipsc_train/42/132845/13448 +- membrane_hipsc_train/42/132929/13513 +- membrane_hipsc_train/42/133133/13640 +- membrane_hipsc_train/42/133323/13465 +- membrane_hipsc_train/42/133324/13457 +- membrane_hipsc_train/42/133325/13497 +- membrane_hipsc_train/42/133503/13577 +- membrane_hipsc_train/42/133504/13572 +- membrane_hipsc_train/42/133602/13711 +- membrane_hipsc_train/42/133711/13788 +- membrane_hipsc_train/42/134272/13918 +- membrane_hipsc_train/42/134286/13916 +- membrane_hipsc_train/42/134656/13884 +- membrane_hipsc_train/42/135272/14059 +- membrane_hipsc_train/42/135440/14128 +- membrane_hipsc_train/42/135525/14245 +- membrane_hipsc_train/42/135614/14178 +- membrane_hipsc_train/42/137434/14771 +- membrane_hipsc_train/42/137464/14708 +- membrane_hipsc_train/42/137767/14413 +- membrane_hipsc_train/42/137772/14516 +- membrane_hipsc_train/42/137956/15501 +- membrane_hipsc_train/42/137956/16613 +- membrane_hipsc_train/42/137956/17196 +- membrane_hipsc_train/42/137956/17224 +- membrane_hipsc_train/42/138024/15890 +- membrane_hipsc_train/42/138028/16174 +- membrane_hipsc_train/42/138032/15577 +- membrane_hipsc_train/42/138261/16083 +- membrane_hipsc_train/42/77912/9479 +- membrane_hipsc_train/42/77912/9520 +- membrane_hipsc_train/42/77923/9543 +- membrane_hipsc_train/42/78389/9675 +- membrane_hipsc_train/42/78391/9672 +- membrane_hipsc_train/42/78487/9750 +- membrane_hipsc_train/42/78487/9758 +- membrane_hipsc_train/42/78691/9802 +- membrane_hipsc_train/42/79541/9897 +- membrane_hipsc_train/42/79552/9894 +- membrane_hipsc_train/42/79554/9874 +- membrane_hipsc_train/42/79828/9972 +- membrane_hipsc_train/42/79831/9969 +- membrane_hipsc_train/42/79832/9978 +- membrane_hipsc_train/42/79841/9963 +- membrane_hipsc_train/42/80023/15006 +- membrane_hipsc_train/42/80033/15189 +- membrane_hipsc_train/42/80035/9980 +- membrane_hipsc_train/42/80224/9960 +- membrane_hipsc_train/42/83392/9630 +test_fovs: +- membrane_hipsc_test/4/11393/1428 +- membrane_hipsc_test/4/11479/1481 +- membrane_hipsc_test/4/18007/1641 +- membrane_hipsc_test/4/18102/1710 +- membrane_hipsc_test/4/18485/1842 +- membrane_hipsc_test/4/22901/3306 +- membrane_hipsc_test/4/27797/2857 +- membrane_hipsc_test/4/28759/3400 +- membrane_hipsc_test/4/29060/3786 +- membrane_hipsc_test/4/29140/3687 +- membrane_hipsc_test/4/29334/3890 +- membrane_hipsc_test/4/30293/3915 +- membrane_hipsc_test/4/31736/15232 +- membrane_hipsc_test/4/32024/4089 +- membrane_hipsc_test/4/34998/4271 +- membrane_hipsc_test/4/35284/4501 +- membrane_hipsc_test/4/36643/4930 +- membrane_hipsc_test/4/37601/5175 +- membrane_hipsc_test/4/38464/5176 +- membrane_hipsc_test/4/4556/15828 +- membrane_hipsc_test/4/4556/16242 +- membrane_hipsc_test/4/5910/824 +- membrane_hipsc_test/4/6497/1014 +- membrane_hipsc_test/4/6775/1242 +- membrane_hipsc_test/4/8706/1138 +- membrane_hipsc_test/4/94507/699 +- membrane_hipsc_test/41/44212/5751 +- membrane_hipsc_test/41/48436/5515 +- membrane_hipsc_test/41/48536/5593 +- membrane_hipsc_test/41/49121/5716 +- membrane_hipsc_test/41/49121/5777 +- membrane_hipsc_test/41/49204/5680 +- membrane_hipsc_test/41/49888/5888 +- membrane_hipsc_test/41/49975/5926 +- membrane_hipsc_test/41/50548/6016 +- membrane_hipsc_test/41/52564/5966 +- membrane_hipsc_test/41/53048/15203 +- membrane_hipsc_test/41/55160/6367 +- membrane_hipsc_test/41/55348/6437 +- membrane_hipsc_test/41/55350/6427 +- membrane_hipsc_test/41/58326/6874 +- membrane_hipsc_test/41/58517/6781 +- membrane_hipsc_test/41/60728/7413 +- membrane_hipsc_test/41/62754/7076 +- membrane_hipsc_test/41/63524/7359 +- membrane_hipsc_test/41/63524/7400 +- membrane_hipsc_test/41/63713/7287 +- membrane_hipsc_test/41/66020/7541 +- membrane_hipsc_test/41/67168/7688 +- membrane_hipsc_test/41/68116/7831 +- membrane_hipsc_test/41/68598/9132 +- membrane_hipsc_test/41/68804/8999 +- membrane_hipsc_test/41/68884/9247 +- membrane_hipsc_test/41/68885/9316 +- membrane_hipsc_test/41/70240/9487 +- membrane_hipsc_test/41/72356/7974 +- membrane_hipsc_test/41/72629/8071 +- membrane_hipsc_test/41/72725/8138 +- membrane_hipsc_test/41/72727/8125 +- membrane_hipsc_test/41/73112/8476 +- membrane_hipsc_test/41/73304/8259 +- membrane_hipsc_test/41/73686/8660 +- membrane_hipsc_test/41/73686/8668 +- membrane_hipsc_test/41/73783/8567 +- membrane_hipsc_test/41/74264/8751 +- membrane_hipsc_test/41/74272/8740 +- membrane_hipsc_test/41/74356/8919 +- membrane_hipsc_test/41/75800/8019 +- membrane_hipsc_test/41/75808/7975 +- membrane_hipsc_test/42/107478/10817 +- membrane_hipsc_test/42/114584/12053 +- membrane_hipsc_test/42/115556/15421 +- membrane_hipsc_test/42/116598/10604 +- membrane_hipsc_test/42/117557/11343 +- membrane_hipsc_test/42/118901/11674 +- membrane_hipsc_test/42/118912/11694 +- membrane_hipsc_test/42/123916/16655 +- membrane_hipsc_test/42/124001/16229 +- membrane_hipsc_test/42/127171/12338 +- membrane_hipsc_test/42/127276/23725 +- membrane_hipsc_test/42/127939/12482 +- membrane_hipsc_test/42/128428/12536 +- membrane_hipsc_test/42/128523/12637 +- membrane_hipsc_test/42/129665/12780 +- membrane_hipsc_test/42/129855/12890 +- membrane_hipsc_test/42/132463/13304 +- membrane_hipsc_test/42/132834/13446 +- membrane_hipsc_test/42/133599/13746 +- membrane_hipsc_test/42/135439/14132 +- membrane_hipsc_test/42/137449/14744 +- membrane_hipsc_test/42/137455/14731 +- membrane_hipsc_test/42/137460/14685 +- membrane_hipsc_test/42/137582/14642 +- membrane_hipsc_test/42/137774/14522 +- membrane_hipsc_test/42/137820/14488 +- membrane_hipsc_test/42/137953/15518 +- membrane_hipsc_test/42/77924/9512 +- membrane_hipsc_test/42/80023/9994 +- membrane_hipsc_test/42/82708/16181 +- membrane_hipsc_test/42/84449/15422 diff --git a/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/membrane_joint_all_v1.yaml b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/membrane_joint_all_v1.yaml new file mode 100644 index 000000000..05a1bda92 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/membrane_joint_all_v1.yaml @@ -0,0 +1,941 @@ +name: membrane_joint_all_v1 +description: Joint frozen benchmark collection across 2 selectors covering targets + 'caax', 'membrane'. Channels and FOV membership captured from the live train/test + zarr stores at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-27T12:03:43.986847+00:00' + created_by: Alex Kalinin +experiments: +- name: membrane_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Membrane + organelle: membrane + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: membrane_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Membrane + organelle: membrane + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: caax_a549_mantis_2026_03_26_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2026_03_26_A549_CAAX_H2B_DENV_ZIKV/train/CAAX.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Membrane + marker: CAAX + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: CAAX + organelle: membrane + pixel_size_xy_um: 0.116 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: caax_a549_mantis_2026_03_26_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2026_03_26_A549_CAAX_H2B_DENV_ZIKV/test/CAAX.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Membrane + marker: CAAX + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: CAAX + organelle: membrane + pixel_size_xy_um: 0.116 + pixel_size_z_um: 0.174 + exclude_fovs: [] +train_fovs: +- membrane_hipsc_train/4/10615/1304 +- membrane_hipsc_train/4/10625/1347 +- membrane_hipsc_train/4/10900/1427 +- membrane_hipsc_train/4/10904/1436 +- membrane_hipsc_train/4/11384/1404 +- membrane_hipsc_train/4/11478/1468 +- membrane_hipsc_train/4/11490/1466 +- membrane_hipsc_train/4/11492/1467 +- membrane_hipsc_train/4/11573/1414 +- membrane_hipsc_train/4/136707/16750 +- membrane_hipsc_train/4/136710/15363 +- membrane_hipsc_train/4/136721/16107 +- membrane_hipsc_train/4/136725/15834 +- membrane_hipsc_train/4/13974/1528 +- membrane_hipsc_train/4/14646/1871 +- membrane_hipsc_train/4/14740/1745 +- membrane_hipsc_train/4/14742/1791 +- membrane_hipsc_train/4/14754/1781 +- membrane_hipsc_train/4/1493/268 +- membrane_hipsc_train/4/1508/255 +- membrane_hipsc_train/4/16278/2186 +- membrane_hipsc_train/4/16376/2374 +- membrane_hipsc_train/4/16468/2321 +- membrane_hipsc_train/4/16469/2337 +- membrane_hipsc_train/4/16469/2339 +- membrane_hipsc_train/4/16469/2345 +- membrane_hipsc_train/4/16471/2265 +- membrane_hipsc_train/4/16472/2312 +- membrane_hipsc_train/4/16951/2459 +- membrane_hipsc_train/4/16951/2480 +- membrane_hipsc_train/4/16952/2494 +- membrane_hipsc_train/4/17333/2710 +- membrane_hipsc_train/4/17348/16148 +- membrane_hipsc_train/4/17525/2811 +- membrane_hipsc_train/4/17526/2752 +- membrane_hipsc_train/4/17536/2773 +- membrane_hipsc_train/4/18020/1618 +- membrane_hipsc_train/4/18020/1625 +- membrane_hipsc_train/4/18020/1638 +- membrane_hipsc_train/4/18487/1811 +- membrane_hipsc_train/4/19351/1905 +- membrane_hipsc_train/4/19543/2105 +- membrane_hipsc_train/4/19554/2020 +- membrane_hipsc_train/4/19556/2089 +- membrane_hipsc_train/4/20416/2223 +- membrane_hipsc_train/4/20596/2406 +- membrane_hipsc_train/4/20597/2395 +- membrane_hipsc_train/4/20597/2401 +- membrane_hipsc_train/4/20599/2373 +- membrane_hipsc_train/4/21077/2254 +- membrane_hipsc_train/4/21089/2293 +- membrane_hipsc_train/4/21556/2491 +- membrane_hipsc_train/4/21557/2483 +- membrane_hipsc_train/4/21557/2527 +- membrane_hipsc_train/4/21653/2547 +- membrane_hipsc_train/4/21860/15671 +- membrane_hipsc_train/4/21940/2736 +- membrane_hipsc_train/4/21943/2717 +- membrane_hipsc_train/4/21953/2739 +- membrane_hipsc_train/4/22133/2826 +- membrane_hipsc_train/4/22136/2827 +- membrane_hipsc_train/4/22339/3095 +- membrane_hipsc_train/4/22340/3097 +- membrane_hipsc_train/4/22612/2915 +- membrane_hipsc_train/4/22614/2923 +- membrane_hipsc_train/4/22615/2978 +- membrane_hipsc_train/4/22624/2909 +- membrane_hipsc_train/4/22709/3070 +- membrane_hipsc_train/4/22712/3090 +- membrane_hipsc_train/4/22913/3301 +- membrane_hipsc_train/4/22914/3289 +- membrane_hipsc_train/4/23380/3237 +- membrane_hipsc_train/4/23392/3212 +- membrane_hipsc_train/4/23395/3223 +- membrane_hipsc_train/4/23574/3492 +- membrane_hipsc_train/4/23764/3409 +- membrane_hipsc_train/4/24152/3567 +- membrane_hipsc_train/4/24724/3661 +- membrane_hipsc_train/4/24727/3659 +- membrane_hipsc_train/4/24928/3585 +- membrane_hipsc_train/4/25784/3851 +- membrane_hipsc_train/4/27800/2883 +- membrane_hipsc_train/4/27896/2943 +- membrane_hipsc_train/4/27992/3020 +- membrane_hipsc_train/4/28084/3214 +- membrane_hipsc_train/4/28084/3270 +- membrane_hipsc_train/4/28087/3266 +- membrane_hipsc_train/4/28756/3381 +- membrane_hipsc_train/4/28759/3393 +- membrane_hipsc_train/4/29045/3764 +- membrane_hipsc_train/4/29060/3753 +- membrane_hipsc_train/4/29143/3667 +- membrane_hipsc_train/4/29155/3710 +- membrane_hipsc_train/4/2932/230 +- membrane_hipsc_train/4/29333/3908 +- membrane_hipsc_train/4/2945/173 +- membrane_hipsc_train/4/30292/14379 +- membrane_hipsc_train/4/30293/3905 +- membrane_hipsc_train/4/30308/3869 +- membrane_hipsc_train/4/30388/16862 +- membrane_hipsc_train/4/30389/15342 +- membrane_hipsc_train/4/30392/16741 +- membrane_hipsc_train/4/31732/17059 +- membrane_hipsc_train/4/31744/16779 +- membrane_hipsc_train/4/31841/3962 +- membrane_hipsc_train/4/31939/3975 +- membrane_hipsc_train/4/32024/4077 +- membrane_hipsc_train/4/32033/4111 +- membrane_hipsc_train/4/32033/4121 +- membrane_hipsc_train/4/32035/4099 +- membrane_hipsc_train/4/33077/4379 +- membrane_hipsc_train/4/33572/4229 +- membrane_hipsc_train/4/33942/15337 +- membrane_hipsc_train/4/33942/16205 +- membrane_hipsc_train/4/33943/17061 +- membrane_hipsc_train/4/33953/16561 +- membrane_hipsc_train/4/33955/16023 +- membrane_hipsc_train/4/34038/4363 +- membrane_hipsc_train/4/34808/4417 +- membrane_hipsc_train/4/35000/4274 +- membrane_hipsc_train/4/35284/4472 +- membrane_hipsc_train/4/35287/4460 +- membrane_hipsc_train/4/35479/4551 +- membrane_hipsc_train/4/35489/4583 +- membrane_hipsc_train/4/36449/15327 +- membrane_hipsc_train/4/36544/4909 +- membrane_hipsc_train/4/36544/4931 +- membrane_hipsc_train/4/36628/4907 +- membrane_hipsc_train/4/36836/4996 +- membrane_hipsc_train/4/37591/5133 +- membrane_hipsc_train/4/37603/5147 +- membrane_hipsc_train/4/37972/5388 +- membrane_hipsc_train/4/37988/5373 +- membrane_hipsc_train/4/40084/5359 +- membrane_hipsc_train/4/40086/5362 +- membrane_hipsc_train/4/40376/4584 +- membrane_hipsc_train/4/40385/4614 +- membrane_hipsc_train/4/40386/4613 +- membrane_hipsc_train/4/40387/4586 +- membrane_hipsc_train/4/40483/4619 +- membrane_hipsc_train/4/40483/4621 +- membrane_hipsc_train/4/40960/4654 +- membrane_hipsc_train/4/41044/4851 +- membrane_hipsc_train/4/41047/4885 +- membrane_hipsc_train/4/41237/4861 +- membrane_hipsc_train/4/41249/4835 +- membrane_hipsc_train/4/41912/5074 +- membrane_hipsc_train/4/5143/954 +- membrane_hipsc_train/4/5236/869 +- membrane_hipsc_train/4/5238/875 +- membrane_hipsc_train/4/6485/1018 +- membrane_hipsc_train/4/6486/992 +- membrane_hipsc_train/4/6497/1003 +- membrane_hipsc_train/4/6775/1203 +- membrane_hipsc_train/4/6775/1226 +- membrane_hipsc_train/4/6775/1236 +- membrane_hipsc_train/4/7156/1124 +- membrane_hipsc_train/4/7349/1355 +- membrane_hipsc_train/4/7650/1278 +- membrane_hipsc_train/4/8214/878 +- membrane_hipsc_train/4/8214/879 +- membrane_hipsc_train/4/8228/898 +- membrane_hipsc_train/4/8695/1215 +- membrane_hipsc_train/4/88267/15294 +- membrane_hipsc_train/4/89048/356 +- membrane_hipsc_train/4/8982/1171 +- membrane_hipsc_train/4/90088/415 +- membrane_hipsc_train/4/90858/15658 +- membrane_hipsc_train/4/90858/16534 +- membrane_hipsc_train/4/91144/102 +- membrane_hipsc_train/4/91924/458 +- membrane_hipsc_train/4/93448/596 +- membrane_hipsc_train/4/94312/684 +- membrane_hipsc_train/4/95752/811 +- membrane_hipsc_train/4/95753/737 +- membrane_hipsc_train/4/95753/872 +- membrane_hipsc_train/41/43638/5246 +- membrane_hipsc_train/41/43639/5265 +- membrane_hipsc_train/41/43732/16519 +- membrane_hipsc_train/41/45556/5706 +- membrane_hipsc_train/41/45556/5734 +- membrane_hipsc_train/41/45559/5714 +- membrane_hipsc_train/41/48436/5507 +- membrane_hipsc_train/41/48534/5575 +- membrane_hipsc_train/41/48535/5623 +- membrane_hipsc_train/41/48548/5574 +- membrane_hipsc_train/41/48548/5589 +- membrane_hipsc_train/41/49204/5661 +- membrane_hipsc_train/41/49220/5671 +- membrane_hipsc_train/41/49698/5819 +- membrane_hipsc_train/41/49972/5933 +- membrane_hipsc_train/41/49973/5960 +- membrane_hipsc_train/41/50263/6077 +- membrane_hipsc_train/41/50263/6082 +- membrane_hipsc_train/41/50356/15510 +- membrane_hipsc_train/41/50356/15578 +- membrane_hipsc_train/41/50359/15457 +- membrane_hipsc_train/41/50548/6024 +- membrane_hipsc_train/41/50551/6022 +- membrane_hipsc_train/41/53044/15243 +- membrane_hipsc_train/41/53046/16965 +- membrane_hipsc_train/41/53428/6238 +- membrane_hipsc_train/41/53524/15636 +- membrane_hipsc_train/41/53538/15395 +- membrane_hipsc_train/41/53731/15920 +- membrane_hipsc_train/41/55156/6355 +- membrane_hipsc_train/41/55156/6358 +- membrane_hipsc_train/41/55158/6324 +- membrane_hipsc_train/41/55158/6353 +- membrane_hipsc_train/41/55253/6499 +- membrane_hipsc_train/41/55256/6482 +- membrane_hipsc_train/41/55351/6419 +- membrane_hipsc_train/41/55363/6362 +- membrane_hipsc_train/41/55925/6584 +- membrane_hipsc_train/41/56406/6643 +- membrane_hipsc_train/41/56416/6614 +- membrane_hipsc_train/41/56418/6626 +- membrane_hipsc_train/41/56419/6630 +- membrane_hipsc_train/41/56596/6678 +- membrane_hipsc_train/41/56896/7720 +- membrane_hipsc_train/41/57364/6456 +- membrane_hipsc_train/41/57365/6428 +- membrane_hipsc_train/41/57367/6430 +- membrane_hipsc_train/41/57464/6544 +- membrane_hipsc_train/41/57472/6556 +- membrane_hipsc_train/41/57472/6565 +- membrane_hipsc_train/41/58134/6821 +- membrane_hipsc_train/41/58326/6840 +- membrane_hipsc_train/41/58420/6971 +- membrane_hipsc_train/41/58423/6963 +- membrane_hipsc_train/41/58518/6786 +- membrane_hipsc_train/41/59285/7118 +- membrane_hipsc_train/41/59285/7124 +- membrane_hipsc_train/41/59298/7175 +- membrane_hipsc_train/41/59380/7015 +- membrane_hipsc_train/41/59479/7188 +- membrane_hipsc_train/41/59479/7200 +- membrane_hipsc_train/41/59480/7179 +- membrane_hipsc_train/41/60548/7475 +- membrane_hipsc_train/41/60632/7345 +- membrane_hipsc_train/41/60726/7399 +- membrane_hipsc_train/41/60737/7332 +- membrane_hipsc_train/41/60738/7414 +- membrane_hipsc_train/41/62740/7068 +- membrane_hipsc_train/41/62932/6916 +- membrane_hipsc_train/41/63508/7389 +- membrane_hipsc_train/41/63523/7383 +- membrane_hipsc_train/41/63608/7462 +- membrane_hipsc_train/41/63608/7464 +- membrane_hipsc_train/41/63620/7451 +- membrane_hipsc_train/41/63701/7283 +- membrane_hipsc_train/41/63713/7256 +- membrane_hipsc_train/41/66292/7775 +- membrane_hipsc_train/41/66292/7782 +- membrane_hipsc_train/41/66292/7796 +- membrane_hipsc_train/41/66296/7788 +- membrane_hipsc_train/41/67157/7690 +- membrane_hipsc_train/41/67168/7678 +- membrane_hipsc_train/41/68131/7834 +- membrane_hipsc_train/41/68503/9206 +- membrane_hipsc_train/41/68504/9176 +- membrane_hipsc_train/41/68504/9197 +- membrane_hipsc_train/41/68512/9188 +- membrane_hipsc_train/41/68512/9207 +- membrane_hipsc_train/41/68512/9212 +- membrane_hipsc_train/41/68708/9065 +- membrane_hipsc_train/41/68788/9030 +- membrane_hipsc_train/41/68800/9019 +- membrane_hipsc_train/41/69472/9285 +- membrane_hipsc_train/41/69473/9279 +- membrane_hipsc_train/41/69474/9306 +- membrane_hipsc_train/41/70052/15689 +- membrane_hipsc_train/41/70231/9525 +- membrane_hipsc_train/41/70232/9551 +- membrane_hipsc_train/41/72244/8037 +- membrane_hipsc_train/41/72244/8074 +- membrane_hipsc_train/41/72256/8049 +- membrane_hipsc_train/41/72260/8085 +- membrane_hipsc_train/41/72342/7994 +- membrane_hipsc_train/41/72356/7962 +- membrane_hipsc_train/41/72628/8109 +- membrane_hipsc_train/41/72629/8086 +- membrane_hipsc_train/41/72630/8119 +- membrane_hipsc_train/41/72631/8095 +- membrane_hipsc_train/41/72725/8151 +- membrane_hipsc_train/41/72726/8128 +- membrane_hipsc_train/41/72834/8288 +- membrane_hipsc_train/41/73300/8255 +- membrane_hipsc_train/41/73396/8265 +- membrane_hipsc_train/41/73397/8271 +- membrane_hipsc_train/41/73398/8307 +- membrane_hipsc_train/41/73495/8186 +- membrane_hipsc_train/41/73507/8203 +- membrane_hipsc_train/41/73685/8634 +- membrane_hipsc_train/41/73687/8628 +- membrane_hipsc_train/41/73700/8663 +- membrane_hipsc_train/41/73782/8525 +- membrane_hipsc_train/41/73782/8576 +- membrane_hipsc_train/41/73783/8530 +- membrane_hipsc_train/41/73784/8543 +- membrane_hipsc_train/41/73879/15995 +- membrane_hipsc_train/41/73975/15832 +- membrane_hipsc_train/41/74165/8821 +- membrane_hipsc_train/41/74168/8793 +- membrane_hipsc_train/41/74260/8727 +- membrane_hipsc_train/41/74273/8721 +- membrane_hipsc_train/41/74371/8941 +- membrane_hipsc_train/41/74371/8978 +- membrane_hipsc_train/41/75042/7915 +- membrane_hipsc_train/41/75124/16978 +- membrane_hipsc_train/41/75125/16693 +- membrane_hipsc_train/41/75512/7872 +- membrane_hipsc_train/41/75796/7941 +- membrane_hipsc_train/41/75799/7953 +- membrane_hipsc_train/41/76000/8244 +- membrane_hipsc_train/41/77250/8868 +- membrane_hipsc_train/41/77333/9094 +- membrane_hipsc_train/42/106420/10373 +- membrane_hipsc_train/42/106421/10380 +- membrane_hipsc_train/42/106422/10368 +- membrane_hipsc_train/42/106516/10272 +- membrane_hipsc_train/42/106518/10239 +- membrane_hipsc_train/42/106520/10262 +- membrane_hipsc_train/42/106915/10747 +- membrane_hipsc_train/42/106996/10652 +- membrane_hipsc_train/42/106998/10641 +- membrane_hipsc_train/42/107480/10815 +- membrane_hipsc_train/42/107480/10822 +- membrane_hipsc_train/42/107572/12022 +- membrane_hipsc_train/42/107574/11982 +- membrane_hipsc_train/42/107574/12039 +- membrane_hipsc_train/42/107682/11895 +- membrane_hipsc_train/42/107682/11898 +- membrane_hipsc_train/42/107684/11928 +- membrane_hipsc_train/42/107956/11969 +- membrane_hipsc_train/42/107956/11981 +- membrane_hipsc_train/42/107958/11911 +- membrane_hipsc_train/42/107959/12029 +- membrane_hipsc_train/42/107972/11941 +- membrane_hipsc_train/42/108148/15673 +- membrane_hipsc_train/42/108149/12190 +- membrane_hipsc_train/42/108246/11135 +- membrane_hipsc_train/42/108248/16355 +- membrane_hipsc_train/42/108824/15581 +- membrane_hipsc_train/42/108833/15155 +- membrane_hipsc_train/42/110548/10130 +- membrane_hipsc_train/42/110552/10154 +- membrane_hipsc_train/42/110552/10175 +- membrane_hipsc_train/42/110645/10108 +- membrane_hipsc_train/42/110646/10124 +- membrane_hipsc_train/42/110660/10091 +- membrane_hipsc_train/42/110947/10199 +- membrane_hipsc_train/42/111125/10242 +- membrane_hipsc_train/42/111413/10485 +- membrane_hipsc_train/42/111415/10486 +- membrane_hipsc_train/42/111426/10473 +- membrane_hipsc_train/42/111892/10724 +- membrane_hipsc_train/42/112084/15061 +- membrane_hipsc_train/42/112085/16293 +- membrane_hipsc_train/42/112280/15454 +- membrane_hipsc_train/42/112565/10904 +- membrane_hipsc_train/42/112758/16064 +- membrane_hipsc_train/42/112772/14973 +- membrane_hipsc_train/42/113432/11852 +- membrane_hipsc_train/42/113634/10939 +- membrane_hipsc_train/42/113921/11053 +- membrane_hipsc_train/42/114209/10977 +- membrane_hipsc_train/42/114212/10981 +- membrane_hipsc_train/42/114787/11121 +- membrane_hipsc_train/42/114788/11097 +- membrane_hipsc_train/42/114965/11232 +- membrane_hipsc_train/42/114965/11269 +- membrane_hipsc_train/42/114979/11222 +- membrane_hipsc_train/42/115160/12126 +- membrane_hipsc_train/42/115169/16617 +- membrane_hipsc_train/42/115349/11410 +- membrane_hipsc_train/42/115541/15346 +- membrane_hipsc_train/42/115542/16879 +- membrane_hipsc_train/42/115552/15185 +- membrane_hipsc_train/42/115554/15716 +- membrane_hipsc_train/42/115555/16425 +- membrane_hipsc_train/42/115556/15703 +- membrane_hipsc_train/42/115831/11479 +- membrane_hipsc_train/42/116034/11497 +- membrane_hipsc_train/42/116309/11595 +- membrane_hipsc_train/42/116324/11616 +- membrane_hipsc_train/42/116608/10515 +- membrane_hipsc_train/42/116608/10614 +- membrane_hipsc_train/42/116887/10440 +- membrane_hipsc_train/42/116897/10412 +- membrane_hipsc_train/42/116900/10422 +- membrane_hipsc_train/42/117173/10673 +- membrane_hipsc_train/42/117186/10657 +- membrane_hipsc_train/42/117557/11347 +- membrane_hipsc_train/42/117559/11367 +- membrane_hipsc_train/42/117572/11385 +- membrane_hipsc_train/42/117847/11299 +- membrane_hipsc_train/42/118420/11731 +- membrane_hipsc_train/42/118423/11658 +- membrane_hipsc_train/42/118712/11569 +- membrane_hipsc_train/42/118806/11804 +- membrane_hipsc_train/42/118808/11800 +- membrane_hipsc_train/42/121791/16666 +- membrane_hipsc_train/42/121793/15852 +- membrane_hipsc_train/42/121806/15946 +- membrane_hipsc_train/42/123328/15550 +- membrane_hipsc_train/42/123328/17092 +- membrane_hipsc_train/42/123714/16851 +- membrane_hipsc_train/42/123903/15431 +- membrane_hipsc_train/42/124002/16132 +- membrane_hipsc_train/42/124014/16885 +- membrane_hipsc_train/42/124205/15565 +- membrane_hipsc_train/42/124287/15382 +- membrane_hipsc_train/42/124290/15483 +- membrane_hipsc_train/42/124291/15731 +- membrane_hipsc_train/42/124299/16712 +- membrane_hipsc_train/42/124301/15843 +- membrane_hipsc_train/42/127171/12333 +- membrane_hipsc_train/42/127647/12252 +- membrane_hipsc_train/42/127648/12223 +- membrane_hipsc_train/42/127649/12208 +- membrane_hipsc_train/42/127650/12238 +- membrane_hipsc_train/42/127650/12256 +- membrane_hipsc_train/42/127651/12217 +- membrane_hipsc_train/42/127651/12239 +- membrane_hipsc_train/42/127852/12320 +- membrane_hipsc_train/42/127935/12457 +- membrane_hipsc_train/42/127947/12485 +- membrane_hipsc_train/42/128416/12512 +- membrane_hipsc_train/42/128514/12657 +- membrane_hipsc_train/42/128514/12667 +- membrane_hipsc_train/42/128525/12654 +- membrane_hipsc_train/42/128715/12598 +- membrane_hipsc_train/42/128718/12626 +- membrane_hipsc_train/42/128719/12625 +- membrane_hipsc_train/42/129473/12830 +- membrane_hipsc_train/42/129473/12852 +- membrane_hipsc_train/42/129571/12811 +- membrane_hipsc_train/42/129583/12802 +- membrane_hipsc_train/42/129774/12715 +- membrane_hipsc_train/42/129855/12931 +- membrane_hipsc_train/42/130155/13043 +- membrane_hipsc_train/42/130527/12960 +- membrane_hipsc_train/42/130625/16186 +- membrane_hipsc_train/42/130707/13231 +- membrane_hipsc_train/42/130722/17097 +- membrane_hipsc_train/42/132173/13409 +- membrane_hipsc_train/42/132175/13365 +- membrane_hipsc_train/42/132653/13278 +- membrane_hipsc_train/42/132831/13415 +- membrane_hipsc_train/42/132844/13432 +- membrane_hipsc_train/42/132845/13448 +- membrane_hipsc_train/42/132929/13513 +- membrane_hipsc_train/42/133133/13640 +- membrane_hipsc_train/42/133323/13465 +- membrane_hipsc_train/42/133324/13457 +- membrane_hipsc_train/42/133325/13497 +- membrane_hipsc_train/42/133503/13577 +- membrane_hipsc_train/42/133504/13572 +- membrane_hipsc_train/42/133602/13711 +- membrane_hipsc_train/42/133711/13788 +- membrane_hipsc_train/42/134272/13918 +- membrane_hipsc_train/42/134286/13916 +- membrane_hipsc_train/42/134656/13884 +- membrane_hipsc_train/42/135272/14059 +- membrane_hipsc_train/42/135440/14128 +- membrane_hipsc_train/42/135525/14245 +- membrane_hipsc_train/42/135614/14178 +- membrane_hipsc_train/42/137434/14771 +- membrane_hipsc_train/42/137464/14708 +- membrane_hipsc_train/42/137767/14413 +- membrane_hipsc_train/42/137772/14516 +- membrane_hipsc_train/42/137956/15501 +- membrane_hipsc_train/42/137956/16613 +- membrane_hipsc_train/42/137956/17196 +- membrane_hipsc_train/42/137956/17224 +- membrane_hipsc_train/42/138024/15890 +- membrane_hipsc_train/42/138028/16174 +- membrane_hipsc_train/42/138032/15577 +- membrane_hipsc_train/42/138261/16083 +- membrane_hipsc_train/42/77912/9479 +- membrane_hipsc_train/42/77912/9520 +- membrane_hipsc_train/42/77923/9543 +- membrane_hipsc_train/42/78389/9675 +- membrane_hipsc_train/42/78391/9672 +- membrane_hipsc_train/42/78487/9750 +- membrane_hipsc_train/42/78487/9758 +- membrane_hipsc_train/42/78691/9802 +- membrane_hipsc_train/42/79541/9897 +- membrane_hipsc_train/42/79552/9894 +- membrane_hipsc_train/42/79554/9874 +- membrane_hipsc_train/42/79828/9972 +- membrane_hipsc_train/42/79831/9969 +- membrane_hipsc_train/42/79832/9978 +- membrane_hipsc_train/42/79841/9963 +- membrane_hipsc_train/42/80023/15006 +- membrane_hipsc_train/42/80033/15189 +- membrane_hipsc_train/42/80035/9980 +- membrane_hipsc_train/42/80224/9960 +- membrane_hipsc_train/42/83392/9630 +- caax_a549_mantis_2026_03_26_train/B/2/000002 +- caax_a549_mantis_2026_03_26_train/B/2/000003 +- caax_a549_mantis_2026_03_26_train/B/2/000005 +- caax_a549_mantis_2026_03_26_train/B/2/000006 +- caax_a549_mantis_2026_03_26_train/B/2/000008 +- caax_a549_mantis_2026_03_26_train/B/2/001000 +- caax_a549_mantis_2026_03_26_train/B/2/001001 +- caax_a549_mantis_2026_03_26_train/B/2/001002 +- caax_a549_mantis_2026_03_26_train/B/2/001003 +- caax_a549_mantis_2026_03_26_train/B/2/001004 +- caax_a549_mantis_2026_03_26_train/B/2/001005 +- caax_a549_mantis_2026_03_26_train/B/2/001006 +- caax_a549_mantis_2026_03_26_train/B/2/001007 +- caax_a549_mantis_2026_03_26_train/B/2/001008 +- caax_a549_mantis_2026_03_26_train/B/2/002000 +- caax_a549_mantis_2026_03_26_train/B/2/002001 +- caax_a549_mantis_2026_03_26_train/B/2/002002 +- caax_a549_mantis_2026_03_26_train/B/2/002003 +- caax_a549_mantis_2026_03_26_train/B/2/002004 +- caax_a549_mantis_2026_03_26_train/B/2/002005 +- caax_a549_mantis_2026_03_26_train/B/2/002006 +- caax_a549_mantis_2026_03_26_train/B/2/002007 +- caax_a549_mantis_2026_03_26_train/B/2/002008 +- caax_a549_mantis_2026_03_26_train/B/2/003000 +- caax_a549_mantis_2026_03_26_train/B/2/003002 +- caax_a549_mantis_2026_03_26_train/B/2/003003 +- caax_a549_mantis_2026_03_26_train/B/2/003005 +- caax_a549_mantis_2026_03_26_train/B/2/003006 +- caax_a549_mantis_2026_03_26_train/B/2/003008 +- caax_a549_mantis_2026_03_26_train/B/2/004000 +- caax_a549_mantis_2026_03_26_train/B/2/004001 +- caax_a549_mantis_2026_03_26_train/B/2/004002 +- caax_a549_mantis_2026_03_26_train/B/2/004003 +- caax_a549_mantis_2026_03_26_train/B/2/004004 +- caax_a549_mantis_2026_03_26_train/B/2/004005 +- caax_a549_mantis_2026_03_26_train/B/2/004006 +- caax_a549_mantis_2026_03_26_train/B/2/004007 +- caax_a549_mantis_2026_03_26_train/B/2/004008 +- caax_a549_mantis_2026_03_26_train/B/2/005000 +- caax_a549_mantis_2026_03_26_train/B/2/005002 +- caax_a549_mantis_2026_03_26_train/B/2/005003 +- caax_a549_mantis_2026_03_26_train/B/2/005005 +- caax_a549_mantis_2026_03_26_train/B/2/005006 +- caax_a549_mantis_2026_03_26_train/B/2/005008 +- caax_a549_mantis_2026_03_26_train/B/2/006000 +- caax_a549_mantis_2026_03_26_train/B/2/006001 +- caax_a549_mantis_2026_03_26_train/B/2/006002 +- caax_a549_mantis_2026_03_26_train/B/2/006003 +- caax_a549_mantis_2026_03_26_train/B/2/006004 +- caax_a549_mantis_2026_03_26_train/B/2/006005 +- caax_a549_mantis_2026_03_26_train/B/2/006006 +- caax_a549_mantis_2026_03_26_train/B/2/006007 +- caax_a549_mantis_2026_03_26_train/B/2/006008 +- caax_a549_mantis_2026_03_26_train/B/2/007000 +- caax_a549_mantis_2026_03_26_train/B/2/007001 +- caax_a549_mantis_2026_03_26_train/B/2/007002 +- caax_a549_mantis_2026_03_26_train/B/2/007003 +- caax_a549_mantis_2026_03_26_train/B/2/007004 +- caax_a549_mantis_2026_03_26_train/B/2/007005 +- caax_a549_mantis_2026_03_26_train/B/2/007006 +- caax_a549_mantis_2026_03_26_train/B/2/007007 +- caax_a549_mantis_2026_03_26_train/B/2/007008 +- caax_a549_mantis_2026_03_26_train/B/2/008000 +- caax_a549_mantis_2026_03_26_train/B/2/008002 +- caax_a549_mantis_2026_03_26_train/B/2/008003 +- caax_a549_mantis_2026_03_26_train/B/2/008005 +- caax_a549_mantis_2026_03_26_train/B/2/008006 +- caax_a549_mantis_2026_03_26_train/B/2/008008 +- caax_a549_mantis_2026_03_26_train/B/3/000000 +- caax_a549_mantis_2026_03_26_train/B/3/000002 +- caax_a549_mantis_2026_03_26_train/B/3/000003 +- caax_a549_mantis_2026_03_26_train/B/3/000005 +- caax_a549_mantis_2026_03_26_train/B/3/000006 +- caax_a549_mantis_2026_03_26_train/B/3/000008 +- caax_a549_mantis_2026_03_26_train/B/3/001000 +- caax_a549_mantis_2026_03_26_train/B/3/001001 +- caax_a549_mantis_2026_03_26_train/B/3/001002 +- caax_a549_mantis_2026_03_26_train/B/3/001003 +- caax_a549_mantis_2026_03_26_train/B/3/001004 +- caax_a549_mantis_2026_03_26_train/B/3/001005 +- caax_a549_mantis_2026_03_26_train/B/3/001006 +- caax_a549_mantis_2026_03_26_train/B/3/001007 +- caax_a549_mantis_2026_03_26_train/B/3/001008 +- caax_a549_mantis_2026_03_26_train/B/3/002000 +- caax_a549_mantis_2026_03_26_train/B/3/002001 +- caax_a549_mantis_2026_03_26_train/B/3/002002 +- caax_a549_mantis_2026_03_26_train/B/3/002003 +- caax_a549_mantis_2026_03_26_train/B/3/002004 +- caax_a549_mantis_2026_03_26_train/B/3/002005 +- caax_a549_mantis_2026_03_26_train/B/3/002006 +- caax_a549_mantis_2026_03_26_train/B/3/002007 +- caax_a549_mantis_2026_03_26_train/B/3/002008 +- caax_a549_mantis_2026_03_26_train/B/3/003000 +- caax_a549_mantis_2026_03_26_train/B/3/003002 +- caax_a549_mantis_2026_03_26_train/B/3/003003 +- caax_a549_mantis_2026_03_26_train/B/3/003005 +- caax_a549_mantis_2026_03_26_train/B/3/003006 +- caax_a549_mantis_2026_03_26_train/B/3/003008 +- caax_a549_mantis_2026_03_26_train/B/3/004000 +- caax_a549_mantis_2026_03_26_train/B/3/004001 +- caax_a549_mantis_2026_03_26_train/B/3/004002 +- caax_a549_mantis_2026_03_26_train/B/3/004003 +- caax_a549_mantis_2026_03_26_train/B/3/004004 +- caax_a549_mantis_2026_03_26_train/B/3/004005 +- caax_a549_mantis_2026_03_26_train/B/3/004006 +- caax_a549_mantis_2026_03_26_train/B/3/004007 +- caax_a549_mantis_2026_03_26_train/B/3/004008 +- caax_a549_mantis_2026_03_26_train/B/3/005000 +- caax_a549_mantis_2026_03_26_train/B/3/005002 +- caax_a549_mantis_2026_03_26_train/B/3/005003 +- caax_a549_mantis_2026_03_26_train/B/3/005005 +- caax_a549_mantis_2026_03_26_train/B/3/005006 +- caax_a549_mantis_2026_03_26_train/B/3/005008 +- caax_a549_mantis_2026_03_26_train/B/3/006000 +- caax_a549_mantis_2026_03_26_train/B/3/006001 +- caax_a549_mantis_2026_03_26_train/B/3/006002 +- caax_a549_mantis_2026_03_26_train/B/3/006003 +- caax_a549_mantis_2026_03_26_train/B/3/006004 +- caax_a549_mantis_2026_03_26_train/B/3/006005 +- caax_a549_mantis_2026_03_26_train/B/3/006006 +- caax_a549_mantis_2026_03_26_train/B/3/006007 +- caax_a549_mantis_2026_03_26_train/B/3/006008 +- caax_a549_mantis_2026_03_26_train/B/3/007000 +- caax_a549_mantis_2026_03_26_train/B/3/007001 +- caax_a549_mantis_2026_03_26_train/B/3/007002 +- caax_a549_mantis_2026_03_26_train/B/3/007003 +- caax_a549_mantis_2026_03_26_train/B/3/007004 +- caax_a549_mantis_2026_03_26_train/B/3/007005 +- caax_a549_mantis_2026_03_26_train/B/3/007006 +- caax_a549_mantis_2026_03_26_train/B/3/007007 +- caax_a549_mantis_2026_03_26_train/B/3/007008 +- caax_a549_mantis_2026_03_26_train/B/3/008000 +- caax_a549_mantis_2026_03_26_train/B/3/008002 +- caax_a549_mantis_2026_03_26_train/B/3/008003 +- caax_a549_mantis_2026_03_26_train/B/3/008005 +- caax_a549_mantis_2026_03_26_train/B/3/008006 +- caax_a549_mantis_2026_03_26_train/B/3/008008 +- caax_a549_mantis_2026_03_26_train/B/4/000000 +- caax_a549_mantis_2026_03_26_train/B/4/000002 +- caax_a549_mantis_2026_03_26_train/B/4/000003 +- caax_a549_mantis_2026_03_26_train/B/4/000005 +- caax_a549_mantis_2026_03_26_train/B/4/000006 +- caax_a549_mantis_2026_03_26_train/B/4/000008 +- caax_a549_mantis_2026_03_26_train/B/4/001000 +- caax_a549_mantis_2026_03_26_train/B/4/001001 +- caax_a549_mantis_2026_03_26_train/B/4/001002 +- caax_a549_mantis_2026_03_26_train/B/4/001003 +- caax_a549_mantis_2026_03_26_train/B/4/001004 +- caax_a549_mantis_2026_03_26_train/B/4/001005 +- caax_a549_mantis_2026_03_26_train/B/4/001006 +- caax_a549_mantis_2026_03_26_train/B/4/001007 +- caax_a549_mantis_2026_03_26_train/B/4/001008 +- caax_a549_mantis_2026_03_26_train/B/4/002000 +- caax_a549_mantis_2026_03_26_train/B/4/002001 +- caax_a549_mantis_2026_03_26_train/B/4/002002 +- caax_a549_mantis_2026_03_26_train/B/4/002003 +- caax_a549_mantis_2026_03_26_train/B/4/002004 +- caax_a549_mantis_2026_03_26_train/B/4/002005 +- caax_a549_mantis_2026_03_26_train/B/4/002006 +- caax_a549_mantis_2026_03_26_train/B/4/002007 +- caax_a549_mantis_2026_03_26_train/B/4/002008 +- caax_a549_mantis_2026_03_26_train/B/4/003000 +- caax_a549_mantis_2026_03_26_train/B/4/003002 +- caax_a549_mantis_2026_03_26_train/B/4/003003 +- caax_a549_mantis_2026_03_26_train/B/4/003005 +- caax_a549_mantis_2026_03_26_train/B/4/003006 +- caax_a549_mantis_2026_03_26_train/B/4/003008 +- caax_a549_mantis_2026_03_26_train/B/4/004000 +- caax_a549_mantis_2026_03_26_train/B/4/004001 +- caax_a549_mantis_2026_03_26_train/B/4/004002 +- caax_a549_mantis_2026_03_26_train/B/4/004003 +- caax_a549_mantis_2026_03_26_train/B/4/004004 +- caax_a549_mantis_2026_03_26_train/B/4/004005 +- caax_a549_mantis_2026_03_26_train/B/4/004006 +- caax_a549_mantis_2026_03_26_train/B/4/004007 +- caax_a549_mantis_2026_03_26_train/B/4/004008 +- caax_a549_mantis_2026_03_26_train/B/4/005000 +- caax_a549_mantis_2026_03_26_train/B/4/005002 +- caax_a549_mantis_2026_03_26_train/B/4/005003 +- caax_a549_mantis_2026_03_26_train/B/4/005005 +- caax_a549_mantis_2026_03_26_train/B/4/005006 +- caax_a549_mantis_2026_03_26_train/B/4/005008 +- caax_a549_mantis_2026_03_26_train/B/4/006000 +- caax_a549_mantis_2026_03_26_train/B/4/006001 +- caax_a549_mantis_2026_03_26_train/B/4/006002 +- caax_a549_mantis_2026_03_26_train/B/4/006003 +- caax_a549_mantis_2026_03_26_train/B/4/006004 +- caax_a549_mantis_2026_03_26_train/B/4/006005 +- caax_a549_mantis_2026_03_26_train/B/4/006006 +- caax_a549_mantis_2026_03_26_train/B/4/006007 +- caax_a549_mantis_2026_03_26_train/B/4/006008 +- caax_a549_mantis_2026_03_26_train/B/4/007000 +- caax_a549_mantis_2026_03_26_train/B/4/007001 +- caax_a549_mantis_2026_03_26_train/B/4/007002 +- caax_a549_mantis_2026_03_26_train/B/4/007003 +- caax_a549_mantis_2026_03_26_train/B/4/007004 +- caax_a549_mantis_2026_03_26_train/B/4/007005 +- caax_a549_mantis_2026_03_26_train/B/4/007006 +- caax_a549_mantis_2026_03_26_train/B/4/007007 +- caax_a549_mantis_2026_03_26_train/B/4/007008 +- caax_a549_mantis_2026_03_26_train/B/4/008000 +- caax_a549_mantis_2026_03_26_train/B/4/008002 +- caax_a549_mantis_2026_03_26_train/B/4/008003 +- caax_a549_mantis_2026_03_26_train/B/4/008005 +- caax_a549_mantis_2026_03_26_train/B/4/008006 +- caax_a549_mantis_2026_03_26_train/B/4/008008 +test_fovs: +- membrane_hipsc_test/4/11393/1428 +- membrane_hipsc_test/4/11479/1481 +- membrane_hipsc_test/4/18007/1641 +- membrane_hipsc_test/4/18102/1710 +- membrane_hipsc_test/4/18485/1842 +- membrane_hipsc_test/4/22901/3306 +- membrane_hipsc_test/4/27797/2857 +- membrane_hipsc_test/4/28759/3400 +- membrane_hipsc_test/4/29060/3786 +- membrane_hipsc_test/4/29140/3687 +- membrane_hipsc_test/4/29334/3890 +- membrane_hipsc_test/4/30293/3915 +- membrane_hipsc_test/4/31736/15232 +- membrane_hipsc_test/4/32024/4089 +- membrane_hipsc_test/4/34998/4271 +- membrane_hipsc_test/4/35284/4501 +- membrane_hipsc_test/4/36643/4930 +- membrane_hipsc_test/4/37601/5175 +- membrane_hipsc_test/4/38464/5176 +- membrane_hipsc_test/4/4556/15828 +- membrane_hipsc_test/4/4556/16242 +- membrane_hipsc_test/4/5910/824 +- membrane_hipsc_test/4/6497/1014 +- membrane_hipsc_test/4/6775/1242 +- membrane_hipsc_test/4/8706/1138 +- membrane_hipsc_test/4/94507/699 +- membrane_hipsc_test/41/44212/5751 +- membrane_hipsc_test/41/48436/5515 +- membrane_hipsc_test/41/48536/5593 +- membrane_hipsc_test/41/49121/5716 +- membrane_hipsc_test/41/49121/5777 +- membrane_hipsc_test/41/49204/5680 +- membrane_hipsc_test/41/49888/5888 +- membrane_hipsc_test/41/49975/5926 +- membrane_hipsc_test/41/50548/6016 +- membrane_hipsc_test/41/52564/5966 +- membrane_hipsc_test/41/53048/15203 +- membrane_hipsc_test/41/55160/6367 +- membrane_hipsc_test/41/55348/6437 +- membrane_hipsc_test/41/55350/6427 +- membrane_hipsc_test/41/58326/6874 +- membrane_hipsc_test/41/58517/6781 +- membrane_hipsc_test/41/60728/7413 +- membrane_hipsc_test/41/62754/7076 +- membrane_hipsc_test/41/63524/7359 +- membrane_hipsc_test/41/63524/7400 +- membrane_hipsc_test/41/63713/7287 +- membrane_hipsc_test/41/66020/7541 +- membrane_hipsc_test/41/67168/7688 +- membrane_hipsc_test/41/68116/7831 +- membrane_hipsc_test/41/68598/9132 +- membrane_hipsc_test/41/68804/8999 +- membrane_hipsc_test/41/68884/9247 +- membrane_hipsc_test/41/68885/9316 +- membrane_hipsc_test/41/70240/9487 +- membrane_hipsc_test/41/72356/7974 +- membrane_hipsc_test/41/72629/8071 +- membrane_hipsc_test/41/72725/8138 +- membrane_hipsc_test/41/72727/8125 +- membrane_hipsc_test/41/73112/8476 +- membrane_hipsc_test/41/73304/8259 +- membrane_hipsc_test/41/73686/8660 +- membrane_hipsc_test/41/73686/8668 +- membrane_hipsc_test/41/73783/8567 +- membrane_hipsc_test/41/74264/8751 +- membrane_hipsc_test/41/74272/8740 +- membrane_hipsc_test/41/74356/8919 +- membrane_hipsc_test/41/75800/8019 +- membrane_hipsc_test/41/75808/7975 +- membrane_hipsc_test/42/107478/10817 +- membrane_hipsc_test/42/114584/12053 +- membrane_hipsc_test/42/115556/15421 +- membrane_hipsc_test/42/116598/10604 +- membrane_hipsc_test/42/117557/11343 +- membrane_hipsc_test/42/118901/11674 +- membrane_hipsc_test/42/118912/11694 +- membrane_hipsc_test/42/123916/16655 +- membrane_hipsc_test/42/124001/16229 +- membrane_hipsc_test/42/127171/12338 +- membrane_hipsc_test/42/127276/23725 +- membrane_hipsc_test/42/127939/12482 +- membrane_hipsc_test/42/128428/12536 +- membrane_hipsc_test/42/128523/12637 +- membrane_hipsc_test/42/129665/12780 +- membrane_hipsc_test/42/129855/12890 +- membrane_hipsc_test/42/132463/13304 +- membrane_hipsc_test/42/132834/13446 +- membrane_hipsc_test/42/133599/13746 +- membrane_hipsc_test/42/135439/14132 +- membrane_hipsc_test/42/137449/14744 +- membrane_hipsc_test/42/137455/14731 +- membrane_hipsc_test/42/137460/14685 +- membrane_hipsc_test/42/137582/14642 +- membrane_hipsc_test/42/137774/14522 +- membrane_hipsc_test/42/137820/14488 +- membrane_hipsc_test/42/137953/15518 +- membrane_hipsc_test/42/77924/9512 +- membrane_hipsc_test/42/80023/9994 +- membrane_hipsc_test/42/82708/16181 +- membrane_hipsc_test/42/84449/15422 +- caax_a549_mantis_2026_03_26_test/B/2/000001 +- caax_a549_mantis_2026_03_26_test/B/2/000004 +- caax_a549_mantis_2026_03_26_test/B/2/000007 +- caax_a549_mantis_2026_03_26_test/B/2/003001 +- caax_a549_mantis_2026_03_26_test/B/2/003004 +- caax_a549_mantis_2026_03_26_test/B/2/003007 +- caax_a549_mantis_2026_03_26_test/B/2/005001 +- caax_a549_mantis_2026_03_26_test/B/2/005004 +- caax_a549_mantis_2026_03_26_test/B/2/005007 +- caax_a549_mantis_2026_03_26_test/B/2/008001 +- caax_a549_mantis_2026_03_26_test/B/2/008004 +- caax_a549_mantis_2026_03_26_test/B/2/008007 +- caax_a549_mantis_2026_03_26_test/B/3/000001 +- caax_a549_mantis_2026_03_26_test/B/3/000004 +- caax_a549_mantis_2026_03_26_test/B/3/000007 +- caax_a549_mantis_2026_03_26_test/B/3/003001 +- caax_a549_mantis_2026_03_26_test/B/3/003004 +- caax_a549_mantis_2026_03_26_test/B/3/003007 +- caax_a549_mantis_2026_03_26_test/B/3/005001 +- caax_a549_mantis_2026_03_26_test/B/3/005004 +- caax_a549_mantis_2026_03_26_test/B/3/005007 +- caax_a549_mantis_2026_03_26_test/B/3/008001 +- caax_a549_mantis_2026_03_26_test/B/3/008004 +- caax_a549_mantis_2026_03_26_test/B/3/008007 +- caax_a549_mantis_2026_03_26_test/B/4/000001 +- caax_a549_mantis_2026_03_26_test/B/4/000004 +- caax_a549_mantis_2026_03_26_test/B/4/000007 +- caax_a549_mantis_2026_03_26_test/B/4/003001 +- caax_a549_mantis_2026_03_26_test/B/4/003004 +- caax_a549_mantis_2026_03_26_test/B/4/003007 +- caax_a549_mantis_2026_03_26_test/B/4/005001 +- caax_a549_mantis_2026_03_26_test/B/4/005004 +- caax_a549_mantis_2026_03_26_test/B/4/005007 +- caax_a549_mantis_2026_03_26_test/B/4/008001 +- caax_a549_mantis_2026_03_26_test/B/4/008004 +- caax_a549_mantis_2026_03_26_test/B/4/008007 diff --git a/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/membrane_joint_mock_v1.yaml b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/membrane_joint_mock_v1.yaml new file mode 100644 index 000000000..286c64ed4 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/membrane_joint_mock_v1.yaml @@ -0,0 +1,779 @@ +name: membrane_joint_mock_v1 +description: Joint frozen benchmark collection with condition filter 'mock' across + 2 selectors covering targets 'caax', 'membrane'. Channels and FOV membership captured + from the live train/test zarr stores at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-27T12:04:03.085047+00:00' + created_by: Alex Kalinin +experiments: +- name: membrane_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Membrane + organelle: membrane + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: membrane_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Membrane + organelle: membrane + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: caax_a549_mantis_2026_03_26_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2026_03_26_A549_CAAX_H2B_DENV_ZIKV/train/CAAX.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Membrane + marker: CAAX + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: CAAX + organelle: membrane + pixel_size_xy_um: 0.116 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: caax_a549_mantis_2026_03_26_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2026_03_26_A549_CAAX_H2B_DENV_ZIKV/test/CAAX.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Membrane + marker: CAAX + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: CAAX + organelle: membrane + pixel_size_xy_um: 0.116 + pixel_size_z_um: 0.174 + exclude_fovs: [] +train_fovs: +- membrane_hipsc_train/4/10615/1304 +- membrane_hipsc_train/4/10625/1347 +- membrane_hipsc_train/4/10900/1427 +- membrane_hipsc_train/4/10904/1436 +- membrane_hipsc_train/4/11384/1404 +- membrane_hipsc_train/4/11478/1468 +- membrane_hipsc_train/4/11490/1466 +- membrane_hipsc_train/4/11492/1467 +- membrane_hipsc_train/4/11573/1414 +- membrane_hipsc_train/4/136707/16750 +- membrane_hipsc_train/4/136710/15363 +- membrane_hipsc_train/4/136721/16107 +- membrane_hipsc_train/4/136725/15834 +- membrane_hipsc_train/4/13974/1528 +- membrane_hipsc_train/4/14646/1871 +- membrane_hipsc_train/4/14740/1745 +- membrane_hipsc_train/4/14742/1791 +- membrane_hipsc_train/4/14754/1781 +- membrane_hipsc_train/4/1493/268 +- membrane_hipsc_train/4/1508/255 +- membrane_hipsc_train/4/16278/2186 +- membrane_hipsc_train/4/16376/2374 +- membrane_hipsc_train/4/16468/2321 +- membrane_hipsc_train/4/16469/2337 +- membrane_hipsc_train/4/16469/2339 +- membrane_hipsc_train/4/16469/2345 +- membrane_hipsc_train/4/16471/2265 +- membrane_hipsc_train/4/16472/2312 +- membrane_hipsc_train/4/16951/2459 +- membrane_hipsc_train/4/16951/2480 +- membrane_hipsc_train/4/16952/2494 +- membrane_hipsc_train/4/17333/2710 +- membrane_hipsc_train/4/17348/16148 +- membrane_hipsc_train/4/17525/2811 +- membrane_hipsc_train/4/17526/2752 +- membrane_hipsc_train/4/17536/2773 +- membrane_hipsc_train/4/18020/1618 +- membrane_hipsc_train/4/18020/1625 +- membrane_hipsc_train/4/18020/1638 +- membrane_hipsc_train/4/18487/1811 +- membrane_hipsc_train/4/19351/1905 +- membrane_hipsc_train/4/19543/2105 +- membrane_hipsc_train/4/19554/2020 +- membrane_hipsc_train/4/19556/2089 +- membrane_hipsc_train/4/20416/2223 +- membrane_hipsc_train/4/20596/2406 +- membrane_hipsc_train/4/20597/2395 +- membrane_hipsc_train/4/20597/2401 +- membrane_hipsc_train/4/20599/2373 +- membrane_hipsc_train/4/21077/2254 +- membrane_hipsc_train/4/21089/2293 +- membrane_hipsc_train/4/21556/2491 +- membrane_hipsc_train/4/21557/2483 +- membrane_hipsc_train/4/21557/2527 +- membrane_hipsc_train/4/21653/2547 +- membrane_hipsc_train/4/21860/15671 +- membrane_hipsc_train/4/21940/2736 +- membrane_hipsc_train/4/21943/2717 +- membrane_hipsc_train/4/21953/2739 +- membrane_hipsc_train/4/22133/2826 +- membrane_hipsc_train/4/22136/2827 +- membrane_hipsc_train/4/22339/3095 +- membrane_hipsc_train/4/22340/3097 +- membrane_hipsc_train/4/22612/2915 +- membrane_hipsc_train/4/22614/2923 +- membrane_hipsc_train/4/22615/2978 +- membrane_hipsc_train/4/22624/2909 +- membrane_hipsc_train/4/22709/3070 +- membrane_hipsc_train/4/22712/3090 +- membrane_hipsc_train/4/22913/3301 +- membrane_hipsc_train/4/22914/3289 +- membrane_hipsc_train/4/23380/3237 +- membrane_hipsc_train/4/23392/3212 +- membrane_hipsc_train/4/23395/3223 +- membrane_hipsc_train/4/23574/3492 +- membrane_hipsc_train/4/23764/3409 +- membrane_hipsc_train/4/24152/3567 +- membrane_hipsc_train/4/24724/3661 +- membrane_hipsc_train/4/24727/3659 +- membrane_hipsc_train/4/24928/3585 +- membrane_hipsc_train/4/25784/3851 +- membrane_hipsc_train/4/27800/2883 +- membrane_hipsc_train/4/27896/2943 +- membrane_hipsc_train/4/27992/3020 +- membrane_hipsc_train/4/28084/3214 +- membrane_hipsc_train/4/28084/3270 +- membrane_hipsc_train/4/28087/3266 +- membrane_hipsc_train/4/28756/3381 +- membrane_hipsc_train/4/28759/3393 +- membrane_hipsc_train/4/29045/3764 +- membrane_hipsc_train/4/29060/3753 +- membrane_hipsc_train/4/29143/3667 +- membrane_hipsc_train/4/29155/3710 +- membrane_hipsc_train/4/2932/230 +- membrane_hipsc_train/4/29333/3908 +- membrane_hipsc_train/4/2945/173 +- membrane_hipsc_train/4/30292/14379 +- membrane_hipsc_train/4/30293/3905 +- membrane_hipsc_train/4/30308/3869 +- membrane_hipsc_train/4/30388/16862 +- membrane_hipsc_train/4/30389/15342 +- membrane_hipsc_train/4/30392/16741 +- membrane_hipsc_train/4/31732/17059 +- membrane_hipsc_train/4/31744/16779 +- membrane_hipsc_train/4/31841/3962 +- membrane_hipsc_train/4/31939/3975 +- membrane_hipsc_train/4/32024/4077 +- membrane_hipsc_train/4/32033/4111 +- membrane_hipsc_train/4/32033/4121 +- membrane_hipsc_train/4/32035/4099 +- membrane_hipsc_train/4/33077/4379 +- membrane_hipsc_train/4/33572/4229 +- membrane_hipsc_train/4/33942/15337 +- membrane_hipsc_train/4/33942/16205 +- membrane_hipsc_train/4/33943/17061 +- membrane_hipsc_train/4/33953/16561 +- membrane_hipsc_train/4/33955/16023 +- membrane_hipsc_train/4/34038/4363 +- membrane_hipsc_train/4/34808/4417 +- membrane_hipsc_train/4/35000/4274 +- membrane_hipsc_train/4/35284/4472 +- membrane_hipsc_train/4/35287/4460 +- membrane_hipsc_train/4/35479/4551 +- membrane_hipsc_train/4/35489/4583 +- membrane_hipsc_train/4/36449/15327 +- membrane_hipsc_train/4/36544/4909 +- membrane_hipsc_train/4/36544/4931 +- membrane_hipsc_train/4/36628/4907 +- membrane_hipsc_train/4/36836/4996 +- membrane_hipsc_train/4/37591/5133 +- membrane_hipsc_train/4/37603/5147 +- membrane_hipsc_train/4/37972/5388 +- membrane_hipsc_train/4/37988/5373 +- membrane_hipsc_train/4/40084/5359 +- membrane_hipsc_train/4/40086/5362 +- membrane_hipsc_train/4/40376/4584 +- membrane_hipsc_train/4/40385/4614 +- membrane_hipsc_train/4/40386/4613 +- membrane_hipsc_train/4/40387/4586 +- membrane_hipsc_train/4/40483/4619 +- membrane_hipsc_train/4/40483/4621 +- membrane_hipsc_train/4/40960/4654 +- membrane_hipsc_train/4/41044/4851 +- membrane_hipsc_train/4/41047/4885 +- membrane_hipsc_train/4/41237/4861 +- membrane_hipsc_train/4/41249/4835 +- membrane_hipsc_train/4/41912/5074 +- membrane_hipsc_train/4/5143/954 +- membrane_hipsc_train/4/5236/869 +- membrane_hipsc_train/4/5238/875 +- membrane_hipsc_train/4/6485/1018 +- membrane_hipsc_train/4/6486/992 +- membrane_hipsc_train/4/6497/1003 +- membrane_hipsc_train/4/6775/1203 +- membrane_hipsc_train/4/6775/1226 +- membrane_hipsc_train/4/6775/1236 +- membrane_hipsc_train/4/7156/1124 +- membrane_hipsc_train/4/7349/1355 +- membrane_hipsc_train/4/7650/1278 +- membrane_hipsc_train/4/8214/878 +- membrane_hipsc_train/4/8214/879 +- membrane_hipsc_train/4/8228/898 +- membrane_hipsc_train/4/8695/1215 +- membrane_hipsc_train/4/88267/15294 +- membrane_hipsc_train/4/89048/356 +- membrane_hipsc_train/4/8982/1171 +- membrane_hipsc_train/4/90088/415 +- membrane_hipsc_train/4/90858/15658 +- membrane_hipsc_train/4/90858/16534 +- membrane_hipsc_train/4/91144/102 +- membrane_hipsc_train/4/91924/458 +- membrane_hipsc_train/4/93448/596 +- membrane_hipsc_train/4/94312/684 +- membrane_hipsc_train/4/95752/811 +- membrane_hipsc_train/4/95753/737 +- membrane_hipsc_train/4/95753/872 +- membrane_hipsc_train/41/43638/5246 +- membrane_hipsc_train/41/43639/5265 +- membrane_hipsc_train/41/43732/16519 +- membrane_hipsc_train/41/45556/5706 +- membrane_hipsc_train/41/45556/5734 +- membrane_hipsc_train/41/45559/5714 +- membrane_hipsc_train/41/48436/5507 +- membrane_hipsc_train/41/48534/5575 +- membrane_hipsc_train/41/48535/5623 +- membrane_hipsc_train/41/48548/5574 +- membrane_hipsc_train/41/48548/5589 +- membrane_hipsc_train/41/49204/5661 +- membrane_hipsc_train/41/49220/5671 +- membrane_hipsc_train/41/49698/5819 +- membrane_hipsc_train/41/49972/5933 +- membrane_hipsc_train/41/49973/5960 +- membrane_hipsc_train/41/50263/6077 +- membrane_hipsc_train/41/50263/6082 +- membrane_hipsc_train/41/50356/15510 +- membrane_hipsc_train/41/50356/15578 +- membrane_hipsc_train/41/50359/15457 +- membrane_hipsc_train/41/50548/6024 +- membrane_hipsc_train/41/50551/6022 +- membrane_hipsc_train/41/53044/15243 +- membrane_hipsc_train/41/53046/16965 +- membrane_hipsc_train/41/53428/6238 +- membrane_hipsc_train/41/53524/15636 +- membrane_hipsc_train/41/53538/15395 +- membrane_hipsc_train/41/53731/15920 +- membrane_hipsc_train/41/55156/6355 +- membrane_hipsc_train/41/55156/6358 +- membrane_hipsc_train/41/55158/6324 +- membrane_hipsc_train/41/55158/6353 +- membrane_hipsc_train/41/55253/6499 +- membrane_hipsc_train/41/55256/6482 +- membrane_hipsc_train/41/55351/6419 +- membrane_hipsc_train/41/55363/6362 +- membrane_hipsc_train/41/55925/6584 +- membrane_hipsc_train/41/56406/6643 +- membrane_hipsc_train/41/56416/6614 +- membrane_hipsc_train/41/56418/6626 +- membrane_hipsc_train/41/56419/6630 +- membrane_hipsc_train/41/56596/6678 +- membrane_hipsc_train/41/56896/7720 +- membrane_hipsc_train/41/57364/6456 +- membrane_hipsc_train/41/57365/6428 +- membrane_hipsc_train/41/57367/6430 +- membrane_hipsc_train/41/57464/6544 +- membrane_hipsc_train/41/57472/6556 +- membrane_hipsc_train/41/57472/6565 +- membrane_hipsc_train/41/58134/6821 +- membrane_hipsc_train/41/58326/6840 +- membrane_hipsc_train/41/58420/6971 +- membrane_hipsc_train/41/58423/6963 +- membrane_hipsc_train/41/58518/6786 +- membrane_hipsc_train/41/59285/7118 +- membrane_hipsc_train/41/59285/7124 +- membrane_hipsc_train/41/59298/7175 +- membrane_hipsc_train/41/59380/7015 +- membrane_hipsc_train/41/59479/7188 +- membrane_hipsc_train/41/59479/7200 +- membrane_hipsc_train/41/59480/7179 +- membrane_hipsc_train/41/60548/7475 +- membrane_hipsc_train/41/60632/7345 +- membrane_hipsc_train/41/60726/7399 +- membrane_hipsc_train/41/60737/7332 +- membrane_hipsc_train/41/60738/7414 +- membrane_hipsc_train/41/62740/7068 +- membrane_hipsc_train/41/62932/6916 +- membrane_hipsc_train/41/63508/7389 +- membrane_hipsc_train/41/63523/7383 +- membrane_hipsc_train/41/63608/7462 +- membrane_hipsc_train/41/63608/7464 +- membrane_hipsc_train/41/63620/7451 +- membrane_hipsc_train/41/63701/7283 +- membrane_hipsc_train/41/63713/7256 +- membrane_hipsc_train/41/66292/7775 +- membrane_hipsc_train/41/66292/7782 +- membrane_hipsc_train/41/66292/7796 +- membrane_hipsc_train/41/66296/7788 +- membrane_hipsc_train/41/67157/7690 +- membrane_hipsc_train/41/67168/7678 +- membrane_hipsc_train/41/68131/7834 +- membrane_hipsc_train/41/68503/9206 +- membrane_hipsc_train/41/68504/9176 +- membrane_hipsc_train/41/68504/9197 +- membrane_hipsc_train/41/68512/9188 +- membrane_hipsc_train/41/68512/9207 +- membrane_hipsc_train/41/68512/9212 +- membrane_hipsc_train/41/68708/9065 +- membrane_hipsc_train/41/68788/9030 +- membrane_hipsc_train/41/68800/9019 +- membrane_hipsc_train/41/69472/9285 +- membrane_hipsc_train/41/69473/9279 +- membrane_hipsc_train/41/69474/9306 +- membrane_hipsc_train/41/70052/15689 +- membrane_hipsc_train/41/70231/9525 +- membrane_hipsc_train/41/70232/9551 +- membrane_hipsc_train/41/72244/8037 +- membrane_hipsc_train/41/72244/8074 +- membrane_hipsc_train/41/72256/8049 +- membrane_hipsc_train/41/72260/8085 +- membrane_hipsc_train/41/72342/7994 +- membrane_hipsc_train/41/72356/7962 +- membrane_hipsc_train/41/72628/8109 +- membrane_hipsc_train/41/72629/8086 +- membrane_hipsc_train/41/72630/8119 +- membrane_hipsc_train/41/72631/8095 +- membrane_hipsc_train/41/72725/8151 +- membrane_hipsc_train/41/72726/8128 +- membrane_hipsc_train/41/72834/8288 +- membrane_hipsc_train/41/73300/8255 +- membrane_hipsc_train/41/73396/8265 +- membrane_hipsc_train/41/73397/8271 +- membrane_hipsc_train/41/73398/8307 +- membrane_hipsc_train/41/73495/8186 +- membrane_hipsc_train/41/73507/8203 +- membrane_hipsc_train/41/73685/8634 +- membrane_hipsc_train/41/73687/8628 +- membrane_hipsc_train/41/73700/8663 +- membrane_hipsc_train/41/73782/8525 +- membrane_hipsc_train/41/73782/8576 +- membrane_hipsc_train/41/73783/8530 +- membrane_hipsc_train/41/73784/8543 +- membrane_hipsc_train/41/73879/15995 +- membrane_hipsc_train/41/73975/15832 +- membrane_hipsc_train/41/74165/8821 +- membrane_hipsc_train/41/74168/8793 +- membrane_hipsc_train/41/74260/8727 +- membrane_hipsc_train/41/74273/8721 +- membrane_hipsc_train/41/74371/8941 +- membrane_hipsc_train/41/74371/8978 +- membrane_hipsc_train/41/75042/7915 +- membrane_hipsc_train/41/75124/16978 +- membrane_hipsc_train/41/75125/16693 +- membrane_hipsc_train/41/75512/7872 +- membrane_hipsc_train/41/75796/7941 +- membrane_hipsc_train/41/75799/7953 +- membrane_hipsc_train/41/76000/8244 +- membrane_hipsc_train/41/77250/8868 +- membrane_hipsc_train/41/77333/9094 +- membrane_hipsc_train/42/106420/10373 +- membrane_hipsc_train/42/106421/10380 +- membrane_hipsc_train/42/106422/10368 +- membrane_hipsc_train/42/106516/10272 +- membrane_hipsc_train/42/106518/10239 +- membrane_hipsc_train/42/106520/10262 +- membrane_hipsc_train/42/106915/10747 +- membrane_hipsc_train/42/106996/10652 +- membrane_hipsc_train/42/106998/10641 +- membrane_hipsc_train/42/107480/10815 +- membrane_hipsc_train/42/107480/10822 +- membrane_hipsc_train/42/107572/12022 +- membrane_hipsc_train/42/107574/11982 +- membrane_hipsc_train/42/107574/12039 +- membrane_hipsc_train/42/107682/11895 +- membrane_hipsc_train/42/107682/11898 +- membrane_hipsc_train/42/107684/11928 +- membrane_hipsc_train/42/107956/11969 +- membrane_hipsc_train/42/107956/11981 +- membrane_hipsc_train/42/107958/11911 +- membrane_hipsc_train/42/107959/12029 +- membrane_hipsc_train/42/107972/11941 +- membrane_hipsc_train/42/108148/15673 +- membrane_hipsc_train/42/108149/12190 +- membrane_hipsc_train/42/108246/11135 +- membrane_hipsc_train/42/108248/16355 +- membrane_hipsc_train/42/108824/15581 +- membrane_hipsc_train/42/108833/15155 +- membrane_hipsc_train/42/110548/10130 +- membrane_hipsc_train/42/110552/10154 +- membrane_hipsc_train/42/110552/10175 +- membrane_hipsc_train/42/110645/10108 +- membrane_hipsc_train/42/110646/10124 +- membrane_hipsc_train/42/110660/10091 +- membrane_hipsc_train/42/110947/10199 +- membrane_hipsc_train/42/111125/10242 +- membrane_hipsc_train/42/111413/10485 +- membrane_hipsc_train/42/111415/10486 +- membrane_hipsc_train/42/111426/10473 +- membrane_hipsc_train/42/111892/10724 +- membrane_hipsc_train/42/112084/15061 +- membrane_hipsc_train/42/112085/16293 +- membrane_hipsc_train/42/112280/15454 +- membrane_hipsc_train/42/112565/10904 +- membrane_hipsc_train/42/112758/16064 +- membrane_hipsc_train/42/112772/14973 +- membrane_hipsc_train/42/113432/11852 +- membrane_hipsc_train/42/113634/10939 +- membrane_hipsc_train/42/113921/11053 +- membrane_hipsc_train/42/114209/10977 +- membrane_hipsc_train/42/114212/10981 +- membrane_hipsc_train/42/114787/11121 +- membrane_hipsc_train/42/114788/11097 +- membrane_hipsc_train/42/114965/11232 +- membrane_hipsc_train/42/114965/11269 +- membrane_hipsc_train/42/114979/11222 +- membrane_hipsc_train/42/115160/12126 +- membrane_hipsc_train/42/115169/16617 +- membrane_hipsc_train/42/115349/11410 +- membrane_hipsc_train/42/115541/15346 +- membrane_hipsc_train/42/115542/16879 +- membrane_hipsc_train/42/115552/15185 +- membrane_hipsc_train/42/115554/15716 +- membrane_hipsc_train/42/115555/16425 +- membrane_hipsc_train/42/115556/15703 +- membrane_hipsc_train/42/115831/11479 +- membrane_hipsc_train/42/116034/11497 +- membrane_hipsc_train/42/116309/11595 +- membrane_hipsc_train/42/116324/11616 +- membrane_hipsc_train/42/116608/10515 +- membrane_hipsc_train/42/116608/10614 +- membrane_hipsc_train/42/116887/10440 +- membrane_hipsc_train/42/116897/10412 +- membrane_hipsc_train/42/116900/10422 +- membrane_hipsc_train/42/117173/10673 +- membrane_hipsc_train/42/117186/10657 +- membrane_hipsc_train/42/117557/11347 +- membrane_hipsc_train/42/117559/11367 +- membrane_hipsc_train/42/117572/11385 +- membrane_hipsc_train/42/117847/11299 +- membrane_hipsc_train/42/118420/11731 +- membrane_hipsc_train/42/118423/11658 +- membrane_hipsc_train/42/118712/11569 +- membrane_hipsc_train/42/118806/11804 +- membrane_hipsc_train/42/118808/11800 +- membrane_hipsc_train/42/121791/16666 +- membrane_hipsc_train/42/121793/15852 +- membrane_hipsc_train/42/121806/15946 +- membrane_hipsc_train/42/123328/15550 +- membrane_hipsc_train/42/123328/17092 +- membrane_hipsc_train/42/123714/16851 +- membrane_hipsc_train/42/123903/15431 +- membrane_hipsc_train/42/124002/16132 +- membrane_hipsc_train/42/124014/16885 +- membrane_hipsc_train/42/124205/15565 +- membrane_hipsc_train/42/124287/15382 +- membrane_hipsc_train/42/124290/15483 +- membrane_hipsc_train/42/124291/15731 +- membrane_hipsc_train/42/124299/16712 +- membrane_hipsc_train/42/124301/15843 +- membrane_hipsc_train/42/127171/12333 +- membrane_hipsc_train/42/127647/12252 +- membrane_hipsc_train/42/127648/12223 +- membrane_hipsc_train/42/127649/12208 +- membrane_hipsc_train/42/127650/12238 +- membrane_hipsc_train/42/127650/12256 +- membrane_hipsc_train/42/127651/12217 +- membrane_hipsc_train/42/127651/12239 +- membrane_hipsc_train/42/127852/12320 +- membrane_hipsc_train/42/127935/12457 +- membrane_hipsc_train/42/127947/12485 +- membrane_hipsc_train/42/128416/12512 +- membrane_hipsc_train/42/128514/12657 +- membrane_hipsc_train/42/128514/12667 +- membrane_hipsc_train/42/128525/12654 +- membrane_hipsc_train/42/128715/12598 +- membrane_hipsc_train/42/128718/12626 +- membrane_hipsc_train/42/128719/12625 +- membrane_hipsc_train/42/129473/12830 +- membrane_hipsc_train/42/129473/12852 +- membrane_hipsc_train/42/129571/12811 +- membrane_hipsc_train/42/129583/12802 +- membrane_hipsc_train/42/129774/12715 +- membrane_hipsc_train/42/129855/12931 +- membrane_hipsc_train/42/130155/13043 +- membrane_hipsc_train/42/130527/12960 +- membrane_hipsc_train/42/130625/16186 +- membrane_hipsc_train/42/130707/13231 +- membrane_hipsc_train/42/130722/17097 +- membrane_hipsc_train/42/132173/13409 +- membrane_hipsc_train/42/132175/13365 +- membrane_hipsc_train/42/132653/13278 +- membrane_hipsc_train/42/132831/13415 +- membrane_hipsc_train/42/132844/13432 +- membrane_hipsc_train/42/132845/13448 +- membrane_hipsc_train/42/132929/13513 +- membrane_hipsc_train/42/133133/13640 +- membrane_hipsc_train/42/133323/13465 +- membrane_hipsc_train/42/133324/13457 +- membrane_hipsc_train/42/133325/13497 +- membrane_hipsc_train/42/133503/13577 +- membrane_hipsc_train/42/133504/13572 +- membrane_hipsc_train/42/133602/13711 +- membrane_hipsc_train/42/133711/13788 +- membrane_hipsc_train/42/134272/13918 +- membrane_hipsc_train/42/134286/13916 +- membrane_hipsc_train/42/134656/13884 +- membrane_hipsc_train/42/135272/14059 +- membrane_hipsc_train/42/135440/14128 +- membrane_hipsc_train/42/135525/14245 +- membrane_hipsc_train/42/135614/14178 +- membrane_hipsc_train/42/137434/14771 +- membrane_hipsc_train/42/137464/14708 +- membrane_hipsc_train/42/137767/14413 +- membrane_hipsc_train/42/137772/14516 +- membrane_hipsc_train/42/137956/15501 +- membrane_hipsc_train/42/137956/16613 +- membrane_hipsc_train/42/137956/17196 +- membrane_hipsc_train/42/137956/17224 +- membrane_hipsc_train/42/138024/15890 +- membrane_hipsc_train/42/138028/16174 +- membrane_hipsc_train/42/138032/15577 +- membrane_hipsc_train/42/138261/16083 +- membrane_hipsc_train/42/77912/9479 +- membrane_hipsc_train/42/77912/9520 +- membrane_hipsc_train/42/77923/9543 +- membrane_hipsc_train/42/78389/9675 +- membrane_hipsc_train/42/78391/9672 +- membrane_hipsc_train/42/78487/9750 +- membrane_hipsc_train/42/78487/9758 +- membrane_hipsc_train/42/78691/9802 +- membrane_hipsc_train/42/79541/9897 +- membrane_hipsc_train/42/79552/9894 +- membrane_hipsc_train/42/79554/9874 +- membrane_hipsc_train/42/79828/9972 +- membrane_hipsc_train/42/79831/9969 +- membrane_hipsc_train/42/79832/9978 +- membrane_hipsc_train/42/79841/9963 +- membrane_hipsc_train/42/80023/15006 +- membrane_hipsc_train/42/80033/15189 +- membrane_hipsc_train/42/80035/9980 +- membrane_hipsc_train/42/80224/9960 +- membrane_hipsc_train/42/83392/9630 +- caax_a549_mantis_2026_03_26_train/B/2/000002 +- caax_a549_mantis_2026_03_26_train/B/2/000003 +- caax_a549_mantis_2026_03_26_train/B/2/000005 +- caax_a549_mantis_2026_03_26_train/B/2/000006 +- caax_a549_mantis_2026_03_26_train/B/2/000008 +- caax_a549_mantis_2026_03_26_train/B/2/001000 +- caax_a549_mantis_2026_03_26_train/B/2/001001 +- caax_a549_mantis_2026_03_26_train/B/2/001002 +- caax_a549_mantis_2026_03_26_train/B/2/001003 +- caax_a549_mantis_2026_03_26_train/B/2/001004 +- caax_a549_mantis_2026_03_26_train/B/2/001005 +- caax_a549_mantis_2026_03_26_train/B/2/001006 +- caax_a549_mantis_2026_03_26_train/B/2/001007 +- caax_a549_mantis_2026_03_26_train/B/2/001008 +- caax_a549_mantis_2026_03_26_train/B/2/002000 +- caax_a549_mantis_2026_03_26_train/B/2/002001 +- caax_a549_mantis_2026_03_26_train/B/2/002002 +- caax_a549_mantis_2026_03_26_train/B/2/002003 +- caax_a549_mantis_2026_03_26_train/B/2/002004 +- caax_a549_mantis_2026_03_26_train/B/2/002005 +- caax_a549_mantis_2026_03_26_train/B/2/002006 +- caax_a549_mantis_2026_03_26_train/B/2/002007 +- caax_a549_mantis_2026_03_26_train/B/2/002008 +- caax_a549_mantis_2026_03_26_train/B/2/003000 +- caax_a549_mantis_2026_03_26_train/B/2/003002 +- caax_a549_mantis_2026_03_26_train/B/2/003003 +- caax_a549_mantis_2026_03_26_train/B/2/003005 +- caax_a549_mantis_2026_03_26_train/B/2/003006 +- caax_a549_mantis_2026_03_26_train/B/2/003008 +- caax_a549_mantis_2026_03_26_train/B/2/004000 +- caax_a549_mantis_2026_03_26_train/B/2/004001 +- caax_a549_mantis_2026_03_26_train/B/2/004002 +- caax_a549_mantis_2026_03_26_train/B/2/004003 +- caax_a549_mantis_2026_03_26_train/B/2/004004 +- caax_a549_mantis_2026_03_26_train/B/2/004005 +- caax_a549_mantis_2026_03_26_train/B/2/004006 +- caax_a549_mantis_2026_03_26_train/B/2/004007 +- caax_a549_mantis_2026_03_26_train/B/2/004008 +- caax_a549_mantis_2026_03_26_train/B/2/005000 +- caax_a549_mantis_2026_03_26_train/B/2/005002 +- caax_a549_mantis_2026_03_26_train/B/2/005003 +- caax_a549_mantis_2026_03_26_train/B/2/005005 +- caax_a549_mantis_2026_03_26_train/B/2/005006 +- caax_a549_mantis_2026_03_26_train/B/2/005008 +- caax_a549_mantis_2026_03_26_train/B/2/006000 +- caax_a549_mantis_2026_03_26_train/B/2/006001 +- caax_a549_mantis_2026_03_26_train/B/2/006002 +- caax_a549_mantis_2026_03_26_train/B/2/006003 +- caax_a549_mantis_2026_03_26_train/B/2/006004 +- caax_a549_mantis_2026_03_26_train/B/2/006005 +- caax_a549_mantis_2026_03_26_train/B/2/006006 +- caax_a549_mantis_2026_03_26_train/B/2/006007 +- caax_a549_mantis_2026_03_26_train/B/2/006008 +- caax_a549_mantis_2026_03_26_train/B/2/007000 +- caax_a549_mantis_2026_03_26_train/B/2/007001 +- caax_a549_mantis_2026_03_26_train/B/2/007002 +- caax_a549_mantis_2026_03_26_train/B/2/007003 +- caax_a549_mantis_2026_03_26_train/B/2/007004 +- caax_a549_mantis_2026_03_26_train/B/2/007005 +- caax_a549_mantis_2026_03_26_train/B/2/007006 +- caax_a549_mantis_2026_03_26_train/B/2/007007 +- caax_a549_mantis_2026_03_26_train/B/2/007008 +- caax_a549_mantis_2026_03_26_train/B/2/008000 +- caax_a549_mantis_2026_03_26_train/B/2/008002 +- caax_a549_mantis_2026_03_26_train/B/2/008003 +- caax_a549_mantis_2026_03_26_train/B/2/008005 +- caax_a549_mantis_2026_03_26_train/B/2/008006 +- caax_a549_mantis_2026_03_26_train/B/2/008008 +test_fovs: +- membrane_hipsc_test/4/11393/1428 +- membrane_hipsc_test/4/11479/1481 +- membrane_hipsc_test/4/18007/1641 +- membrane_hipsc_test/4/18102/1710 +- membrane_hipsc_test/4/18485/1842 +- membrane_hipsc_test/4/22901/3306 +- membrane_hipsc_test/4/27797/2857 +- membrane_hipsc_test/4/28759/3400 +- membrane_hipsc_test/4/29060/3786 +- membrane_hipsc_test/4/29140/3687 +- membrane_hipsc_test/4/29334/3890 +- membrane_hipsc_test/4/30293/3915 +- membrane_hipsc_test/4/31736/15232 +- membrane_hipsc_test/4/32024/4089 +- membrane_hipsc_test/4/34998/4271 +- membrane_hipsc_test/4/35284/4501 +- membrane_hipsc_test/4/36643/4930 +- membrane_hipsc_test/4/37601/5175 +- membrane_hipsc_test/4/38464/5176 +- membrane_hipsc_test/4/4556/15828 +- membrane_hipsc_test/4/4556/16242 +- membrane_hipsc_test/4/5910/824 +- membrane_hipsc_test/4/6497/1014 +- membrane_hipsc_test/4/6775/1242 +- membrane_hipsc_test/4/8706/1138 +- membrane_hipsc_test/4/94507/699 +- membrane_hipsc_test/41/44212/5751 +- membrane_hipsc_test/41/48436/5515 +- membrane_hipsc_test/41/48536/5593 +- membrane_hipsc_test/41/49121/5716 +- membrane_hipsc_test/41/49121/5777 +- membrane_hipsc_test/41/49204/5680 +- membrane_hipsc_test/41/49888/5888 +- membrane_hipsc_test/41/49975/5926 +- membrane_hipsc_test/41/50548/6016 +- membrane_hipsc_test/41/52564/5966 +- membrane_hipsc_test/41/53048/15203 +- membrane_hipsc_test/41/55160/6367 +- membrane_hipsc_test/41/55348/6437 +- membrane_hipsc_test/41/55350/6427 +- membrane_hipsc_test/41/58326/6874 +- membrane_hipsc_test/41/58517/6781 +- membrane_hipsc_test/41/60728/7413 +- membrane_hipsc_test/41/62754/7076 +- membrane_hipsc_test/41/63524/7359 +- membrane_hipsc_test/41/63524/7400 +- membrane_hipsc_test/41/63713/7287 +- membrane_hipsc_test/41/66020/7541 +- membrane_hipsc_test/41/67168/7688 +- membrane_hipsc_test/41/68116/7831 +- membrane_hipsc_test/41/68598/9132 +- membrane_hipsc_test/41/68804/8999 +- membrane_hipsc_test/41/68884/9247 +- membrane_hipsc_test/41/68885/9316 +- membrane_hipsc_test/41/70240/9487 +- membrane_hipsc_test/41/72356/7974 +- membrane_hipsc_test/41/72629/8071 +- membrane_hipsc_test/41/72725/8138 +- membrane_hipsc_test/41/72727/8125 +- membrane_hipsc_test/41/73112/8476 +- membrane_hipsc_test/41/73304/8259 +- membrane_hipsc_test/41/73686/8660 +- membrane_hipsc_test/41/73686/8668 +- membrane_hipsc_test/41/73783/8567 +- membrane_hipsc_test/41/74264/8751 +- membrane_hipsc_test/41/74272/8740 +- membrane_hipsc_test/41/74356/8919 +- membrane_hipsc_test/41/75800/8019 +- membrane_hipsc_test/41/75808/7975 +- membrane_hipsc_test/42/107478/10817 +- membrane_hipsc_test/42/114584/12053 +- membrane_hipsc_test/42/115556/15421 +- membrane_hipsc_test/42/116598/10604 +- membrane_hipsc_test/42/117557/11343 +- membrane_hipsc_test/42/118901/11674 +- membrane_hipsc_test/42/118912/11694 +- membrane_hipsc_test/42/123916/16655 +- membrane_hipsc_test/42/124001/16229 +- membrane_hipsc_test/42/127171/12338 +- membrane_hipsc_test/42/127276/23725 +- membrane_hipsc_test/42/127939/12482 +- membrane_hipsc_test/42/128428/12536 +- membrane_hipsc_test/42/128523/12637 +- membrane_hipsc_test/42/129665/12780 +- membrane_hipsc_test/42/129855/12890 +- membrane_hipsc_test/42/132463/13304 +- membrane_hipsc_test/42/132834/13446 +- membrane_hipsc_test/42/133599/13746 +- membrane_hipsc_test/42/135439/14132 +- membrane_hipsc_test/42/137449/14744 +- membrane_hipsc_test/42/137455/14731 +- membrane_hipsc_test/42/137460/14685 +- membrane_hipsc_test/42/137582/14642 +- membrane_hipsc_test/42/137774/14522 +- membrane_hipsc_test/42/137820/14488 +- membrane_hipsc_test/42/137953/15518 +- membrane_hipsc_test/42/77924/9512 +- membrane_hipsc_test/42/80023/9994 +- membrane_hipsc_test/42/82708/16181 +- membrane_hipsc_test/42/84449/15422 +- caax_a549_mantis_2026_03_26_test/B/2/000001 +- caax_a549_mantis_2026_03_26_test/B/2/000004 +- caax_a549_mantis_2026_03_26_test/B/2/000007 +- caax_a549_mantis_2026_03_26_test/B/2/003001 +- caax_a549_mantis_2026_03_26_test/B/2/003004 +- caax_a549_mantis_2026_03_26_test/B/2/003007 +- caax_a549_mantis_2026_03_26_test/B/2/005001 +- caax_a549_mantis_2026_03_26_test/B/2/005004 +- caax_a549_mantis_2026_03_26_test/B/2/005007 +- caax_a549_mantis_2026_03_26_test/B/2/008001 +- caax_a549_mantis_2026_03_26_test/B/2/008004 +- caax_a549_mantis_2026_03_26_test/B/2/008007 diff --git a/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/nucleus_ipsc_v1.yaml b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/nucleus_ipsc_v1.yaml new file mode 100644 index 000000000..c6d076bcc --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/nucleus_ipsc_v1.yaml @@ -0,0 +1,658 @@ +name: nucleus_ipsc_v1 +description: Frozen benchmark collection for 'aics-hipsc' target 'nucleus'. Channels + and FOV membership captured from the live train/test zarr stores at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-27T12:02:09.776033+00:00' + created_by: Alex Kalinin +experiments: +- name: nucleus_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Nuclei + organelle: nucleus + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: nucleus_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Nuclei + organelle: nucleus + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +train_fovs: +- nucleus_hipsc_train/4/10615/1304 +- nucleus_hipsc_train/4/10625/1347 +- nucleus_hipsc_train/4/10900/1427 +- nucleus_hipsc_train/4/10904/1436 +- nucleus_hipsc_train/4/11384/1404 +- nucleus_hipsc_train/4/11478/1468 +- nucleus_hipsc_train/4/11490/1466 +- nucleus_hipsc_train/4/11492/1467 +- nucleus_hipsc_train/4/11573/1414 +- nucleus_hipsc_train/4/136707/16750 +- nucleus_hipsc_train/4/136710/15363 +- nucleus_hipsc_train/4/136721/16107 +- nucleus_hipsc_train/4/136725/15834 +- nucleus_hipsc_train/4/13974/1528 +- nucleus_hipsc_train/4/14646/1871 +- nucleus_hipsc_train/4/14740/1745 +- nucleus_hipsc_train/4/14742/1791 +- nucleus_hipsc_train/4/14754/1781 +- nucleus_hipsc_train/4/1493/268 +- nucleus_hipsc_train/4/1508/255 +- nucleus_hipsc_train/4/16278/2186 +- nucleus_hipsc_train/4/16376/2374 +- nucleus_hipsc_train/4/16468/2321 +- nucleus_hipsc_train/4/16469/2337 +- nucleus_hipsc_train/4/16469/2339 +- nucleus_hipsc_train/4/16469/2345 +- nucleus_hipsc_train/4/16471/2265 +- nucleus_hipsc_train/4/16472/2312 +- nucleus_hipsc_train/4/16951/2459 +- nucleus_hipsc_train/4/16951/2480 +- nucleus_hipsc_train/4/16952/2494 +- nucleus_hipsc_train/4/17333/2710 +- nucleus_hipsc_train/4/17348/16148 +- nucleus_hipsc_train/4/17525/2811 +- nucleus_hipsc_train/4/17526/2752 +- nucleus_hipsc_train/4/17536/2773 +- nucleus_hipsc_train/4/18020/1618 +- nucleus_hipsc_train/4/18020/1625 +- nucleus_hipsc_train/4/18020/1638 +- nucleus_hipsc_train/4/18487/1811 +- nucleus_hipsc_train/4/19351/1905 +- nucleus_hipsc_train/4/19543/2105 +- nucleus_hipsc_train/4/19554/2020 +- nucleus_hipsc_train/4/19556/2089 +- nucleus_hipsc_train/4/20416/2223 +- nucleus_hipsc_train/4/20596/2406 +- nucleus_hipsc_train/4/20597/2395 +- nucleus_hipsc_train/4/20597/2401 +- nucleus_hipsc_train/4/20599/2373 +- nucleus_hipsc_train/4/21077/2254 +- nucleus_hipsc_train/4/21089/2293 +- nucleus_hipsc_train/4/21556/2491 +- nucleus_hipsc_train/4/21557/2483 +- nucleus_hipsc_train/4/21557/2527 +- nucleus_hipsc_train/4/21653/2547 +- nucleus_hipsc_train/4/21860/15671 +- nucleus_hipsc_train/4/21940/2736 +- nucleus_hipsc_train/4/21943/2717 +- nucleus_hipsc_train/4/21953/2739 +- nucleus_hipsc_train/4/22133/2826 +- nucleus_hipsc_train/4/22136/2827 +- nucleus_hipsc_train/4/22339/3095 +- nucleus_hipsc_train/4/22340/3097 +- nucleus_hipsc_train/4/22612/2915 +- nucleus_hipsc_train/4/22614/2923 +- nucleus_hipsc_train/4/22615/2978 +- nucleus_hipsc_train/4/22624/2909 +- nucleus_hipsc_train/4/22709/3070 +- nucleus_hipsc_train/4/22712/3090 +- nucleus_hipsc_train/4/22913/3301 +- nucleus_hipsc_train/4/22914/3289 +- nucleus_hipsc_train/4/23380/3237 +- nucleus_hipsc_train/4/23392/3212 +- nucleus_hipsc_train/4/23395/3223 +- nucleus_hipsc_train/4/23574/3492 +- nucleus_hipsc_train/4/23764/3409 +- nucleus_hipsc_train/4/24152/3567 +- nucleus_hipsc_train/4/24724/3661 +- nucleus_hipsc_train/4/24727/3659 +- nucleus_hipsc_train/4/24928/3585 +- nucleus_hipsc_train/4/25784/3851 +- nucleus_hipsc_train/4/27800/2883 +- nucleus_hipsc_train/4/27896/2943 +- nucleus_hipsc_train/4/27992/3020 +- nucleus_hipsc_train/4/28084/3214 +- nucleus_hipsc_train/4/28084/3270 +- nucleus_hipsc_train/4/28087/3266 +- nucleus_hipsc_train/4/28756/3381 +- nucleus_hipsc_train/4/28759/3393 +- nucleus_hipsc_train/4/29045/3764 +- nucleus_hipsc_train/4/29060/3753 +- nucleus_hipsc_train/4/29143/3667 +- nucleus_hipsc_train/4/29155/3710 +- nucleus_hipsc_train/4/2932/230 +- nucleus_hipsc_train/4/29333/3908 +- nucleus_hipsc_train/4/2945/173 +- nucleus_hipsc_train/4/30292/14379 +- nucleus_hipsc_train/4/30293/3905 +- nucleus_hipsc_train/4/30308/3869 +- nucleus_hipsc_train/4/30388/16862 +- nucleus_hipsc_train/4/30389/15342 +- nucleus_hipsc_train/4/30392/16741 +- nucleus_hipsc_train/4/31732/17059 +- nucleus_hipsc_train/4/31744/16779 +- nucleus_hipsc_train/4/31841/3962 +- nucleus_hipsc_train/4/31939/3975 +- nucleus_hipsc_train/4/32024/4077 +- nucleus_hipsc_train/4/32033/4111 +- nucleus_hipsc_train/4/32033/4121 +- nucleus_hipsc_train/4/32035/4099 +- nucleus_hipsc_train/4/33077/4379 +- nucleus_hipsc_train/4/33572/4229 +- nucleus_hipsc_train/4/33942/15337 +- nucleus_hipsc_train/4/33942/16205 +- nucleus_hipsc_train/4/33943/17061 +- nucleus_hipsc_train/4/33953/16561 +- nucleus_hipsc_train/4/33955/16023 +- nucleus_hipsc_train/4/34038/4363 +- nucleus_hipsc_train/4/34808/4417 +- nucleus_hipsc_train/4/35000/4274 +- nucleus_hipsc_train/4/35284/4472 +- nucleus_hipsc_train/4/35287/4460 +- nucleus_hipsc_train/4/35479/4551 +- nucleus_hipsc_train/4/35489/4583 +- nucleus_hipsc_train/4/36449/15327 +- nucleus_hipsc_train/4/36544/4909 +- nucleus_hipsc_train/4/36544/4931 +- nucleus_hipsc_train/4/36628/4907 +- nucleus_hipsc_train/4/36836/4996 +- nucleus_hipsc_train/4/37591/5133 +- nucleus_hipsc_train/4/37603/5147 +- nucleus_hipsc_train/4/37972/5388 +- nucleus_hipsc_train/4/37988/5373 +- nucleus_hipsc_train/4/40084/5359 +- nucleus_hipsc_train/4/40086/5362 +- nucleus_hipsc_train/4/40376/4584 +- nucleus_hipsc_train/4/40385/4614 +- nucleus_hipsc_train/4/40386/4613 +- nucleus_hipsc_train/4/40387/4586 +- nucleus_hipsc_train/4/40483/4619 +- nucleus_hipsc_train/4/40483/4621 +- nucleus_hipsc_train/4/40960/4654 +- nucleus_hipsc_train/4/41044/4851 +- nucleus_hipsc_train/4/41047/4885 +- nucleus_hipsc_train/4/41237/4861 +- nucleus_hipsc_train/4/41249/4835 +- nucleus_hipsc_train/4/41912/5074 +- nucleus_hipsc_train/4/5143/954 +- nucleus_hipsc_train/4/5236/869 +- nucleus_hipsc_train/4/5238/875 +- nucleus_hipsc_train/4/6485/1018 +- nucleus_hipsc_train/4/6486/992 +- nucleus_hipsc_train/4/6497/1003 +- nucleus_hipsc_train/4/6775/1203 +- nucleus_hipsc_train/4/6775/1226 +- nucleus_hipsc_train/4/6775/1236 +- nucleus_hipsc_train/4/7156/1124 +- nucleus_hipsc_train/4/7349/1355 +- nucleus_hipsc_train/4/7650/1278 +- nucleus_hipsc_train/4/8214/878 +- nucleus_hipsc_train/4/8214/879 +- nucleus_hipsc_train/4/8228/898 +- nucleus_hipsc_train/4/8695/1215 +- nucleus_hipsc_train/4/88267/15294 +- nucleus_hipsc_train/4/89048/356 +- nucleus_hipsc_train/4/8982/1171 +- nucleus_hipsc_train/4/90088/415 +- nucleus_hipsc_train/4/90858/15658 +- nucleus_hipsc_train/4/90858/16534 +- nucleus_hipsc_train/4/91144/102 +- nucleus_hipsc_train/4/91924/458 +- nucleus_hipsc_train/4/93448/596 +- nucleus_hipsc_train/4/94312/684 +- nucleus_hipsc_train/4/95752/811 +- nucleus_hipsc_train/4/95753/737 +- nucleus_hipsc_train/4/95753/872 +- nucleus_hipsc_train/41/43638/5246 +- nucleus_hipsc_train/41/43639/5265 +- nucleus_hipsc_train/41/43732/16519 +- nucleus_hipsc_train/41/45556/5706 +- nucleus_hipsc_train/41/45556/5734 +- nucleus_hipsc_train/41/45559/5714 +- nucleus_hipsc_train/41/48436/5507 +- nucleus_hipsc_train/41/48534/5575 +- nucleus_hipsc_train/41/48535/5623 +- nucleus_hipsc_train/41/48548/5574 +- nucleus_hipsc_train/41/48548/5589 +- nucleus_hipsc_train/41/49204/5661 +- nucleus_hipsc_train/41/49220/5671 +- nucleus_hipsc_train/41/49698/5819 +- nucleus_hipsc_train/41/49972/5933 +- nucleus_hipsc_train/41/49973/5960 +- nucleus_hipsc_train/41/50263/6077 +- nucleus_hipsc_train/41/50263/6082 +- nucleus_hipsc_train/41/50356/15510 +- nucleus_hipsc_train/41/50356/15578 +- nucleus_hipsc_train/41/50359/15457 +- nucleus_hipsc_train/41/50548/6024 +- nucleus_hipsc_train/41/50551/6022 +- nucleus_hipsc_train/41/53044/15243 +- nucleus_hipsc_train/41/53046/16965 +- nucleus_hipsc_train/41/53428/6238 +- nucleus_hipsc_train/41/53524/15636 +- nucleus_hipsc_train/41/53538/15395 +- nucleus_hipsc_train/41/53731/15920 +- nucleus_hipsc_train/41/55156/6355 +- nucleus_hipsc_train/41/55156/6358 +- nucleus_hipsc_train/41/55158/6324 +- nucleus_hipsc_train/41/55158/6353 +- nucleus_hipsc_train/41/55253/6499 +- nucleus_hipsc_train/41/55256/6482 +- nucleus_hipsc_train/41/55351/6419 +- nucleus_hipsc_train/41/55363/6362 +- nucleus_hipsc_train/41/55925/6584 +- nucleus_hipsc_train/41/56406/6643 +- nucleus_hipsc_train/41/56416/6614 +- nucleus_hipsc_train/41/56418/6626 +- nucleus_hipsc_train/41/56419/6630 +- nucleus_hipsc_train/41/56596/6678 +- nucleus_hipsc_train/41/56896/7720 +- nucleus_hipsc_train/41/57364/6456 +- nucleus_hipsc_train/41/57365/6428 +- nucleus_hipsc_train/41/57367/6430 +- nucleus_hipsc_train/41/57464/6544 +- nucleus_hipsc_train/41/57472/6556 +- nucleus_hipsc_train/41/57472/6565 +- nucleus_hipsc_train/41/58134/6821 +- nucleus_hipsc_train/41/58326/6840 +- nucleus_hipsc_train/41/58420/6971 +- nucleus_hipsc_train/41/58423/6963 +- nucleus_hipsc_train/41/58518/6786 +- nucleus_hipsc_train/41/59285/7118 +- nucleus_hipsc_train/41/59285/7124 +- nucleus_hipsc_train/41/59298/7175 +- nucleus_hipsc_train/41/59380/7015 +- nucleus_hipsc_train/41/59479/7188 +- nucleus_hipsc_train/41/59479/7200 +- nucleus_hipsc_train/41/59480/7179 +- nucleus_hipsc_train/41/60548/7475 +- nucleus_hipsc_train/41/60632/7345 +- nucleus_hipsc_train/41/60726/7399 +- nucleus_hipsc_train/41/60737/7332 +- nucleus_hipsc_train/41/60738/7414 +- nucleus_hipsc_train/41/62740/7068 +- nucleus_hipsc_train/41/62932/6916 +- nucleus_hipsc_train/41/63508/7389 +- nucleus_hipsc_train/41/63523/7383 +- nucleus_hipsc_train/41/63608/7462 +- nucleus_hipsc_train/41/63608/7464 +- nucleus_hipsc_train/41/63620/7451 +- nucleus_hipsc_train/41/63701/7283 +- nucleus_hipsc_train/41/63713/7256 +- nucleus_hipsc_train/41/66292/7775 +- nucleus_hipsc_train/41/66292/7782 +- nucleus_hipsc_train/41/66292/7796 +- nucleus_hipsc_train/41/66296/7788 +- nucleus_hipsc_train/41/67157/7690 +- nucleus_hipsc_train/41/67168/7678 +- nucleus_hipsc_train/41/68131/7834 +- nucleus_hipsc_train/41/68503/9206 +- nucleus_hipsc_train/41/68504/9176 +- nucleus_hipsc_train/41/68504/9197 +- nucleus_hipsc_train/41/68512/9188 +- nucleus_hipsc_train/41/68512/9207 +- nucleus_hipsc_train/41/68512/9212 +- nucleus_hipsc_train/41/68708/9065 +- nucleus_hipsc_train/41/68788/9030 +- nucleus_hipsc_train/41/68800/9019 +- nucleus_hipsc_train/41/69472/9285 +- nucleus_hipsc_train/41/69473/9279 +- nucleus_hipsc_train/41/69474/9306 +- nucleus_hipsc_train/41/70052/15689 +- nucleus_hipsc_train/41/70231/9525 +- nucleus_hipsc_train/41/70232/9551 +- nucleus_hipsc_train/41/72244/8037 +- nucleus_hipsc_train/41/72244/8074 +- nucleus_hipsc_train/41/72256/8049 +- nucleus_hipsc_train/41/72260/8085 +- nucleus_hipsc_train/41/72342/7994 +- nucleus_hipsc_train/41/72356/7962 +- nucleus_hipsc_train/41/72628/8109 +- nucleus_hipsc_train/41/72629/8086 +- nucleus_hipsc_train/41/72630/8119 +- nucleus_hipsc_train/41/72631/8095 +- nucleus_hipsc_train/41/72725/8151 +- nucleus_hipsc_train/41/72726/8128 +- nucleus_hipsc_train/41/72834/8288 +- nucleus_hipsc_train/41/73300/8255 +- nucleus_hipsc_train/41/73396/8265 +- nucleus_hipsc_train/41/73397/8271 +- nucleus_hipsc_train/41/73398/8307 +- nucleus_hipsc_train/41/73495/8186 +- nucleus_hipsc_train/41/73507/8203 +- nucleus_hipsc_train/41/73685/8634 +- nucleus_hipsc_train/41/73687/8628 +- nucleus_hipsc_train/41/73700/8663 +- nucleus_hipsc_train/41/73782/8525 +- nucleus_hipsc_train/41/73782/8576 +- nucleus_hipsc_train/41/73783/8530 +- nucleus_hipsc_train/41/73784/8543 +- nucleus_hipsc_train/41/73879/15995 +- nucleus_hipsc_train/41/73975/15832 +- nucleus_hipsc_train/41/74165/8821 +- nucleus_hipsc_train/41/74168/8793 +- nucleus_hipsc_train/41/74260/8727 +- nucleus_hipsc_train/41/74273/8721 +- nucleus_hipsc_train/41/74371/8941 +- nucleus_hipsc_train/41/74371/8978 +- nucleus_hipsc_train/41/75042/7915 +- nucleus_hipsc_train/41/75124/16978 +- nucleus_hipsc_train/41/75125/16693 +- nucleus_hipsc_train/41/75512/7872 +- nucleus_hipsc_train/41/75796/7941 +- nucleus_hipsc_train/41/75799/7953 +- nucleus_hipsc_train/41/76000/8244 +- nucleus_hipsc_train/41/77250/8868 +- nucleus_hipsc_train/41/77333/9094 +- nucleus_hipsc_train/42/106420/10373 +- nucleus_hipsc_train/42/106421/10380 +- nucleus_hipsc_train/42/106422/10368 +- nucleus_hipsc_train/42/106516/10272 +- nucleus_hipsc_train/42/106518/10239 +- nucleus_hipsc_train/42/106520/10262 +- nucleus_hipsc_train/42/106915/10747 +- nucleus_hipsc_train/42/106996/10652 +- nucleus_hipsc_train/42/106998/10641 +- nucleus_hipsc_train/42/107480/10815 +- nucleus_hipsc_train/42/107480/10822 +- nucleus_hipsc_train/42/107572/12022 +- nucleus_hipsc_train/42/107574/11982 +- nucleus_hipsc_train/42/107574/12039 +- nucleus_hipsc_train/42/107682/11895 +- nucleus_hipsc_train/42/107682/11898 +- nucleus_hipsc_train/42/107684/11928 +- nucleus_hipsc_train/42/107956/11969 +- nucleus_hipsc_train/42/107956/11981 +- nucleus_hipsc_train/42/107958/11911 +- nucleus_hipsc_train/42/107959/12029 +- nucleus_hipsc_train/42/107972/11941 +- nucleus_hipsc_train/42/108148/15673 +- nucleus_hipsc_train/42/108149/12190 +- nucleus_hipsc_train/42/108246/11135 +- nucleus_hipsc_train/42/108248/16355 +- nucleus_hipsc_train/42/108824/15581 +- nucleus_hipsc_train/42/108833/15155 +- nucleus_hipsc_train/42/110548/10130 +- nucleus_hipsc_train/42/110552/10154 +- nucleus_hipsc_train/42/110552/10175 +- nucleus_hipsc_train/42/110645/10108 +- nucleus_hipsc_train/42/110646/10124 +- nucleus_hipsc_train/42/110660/10091 +- nucleus_hipsc_train/42/110947/10199 +- nucleus_hipsc_train/42/111125/10242 +- nucleus_hipsc_train/42/111413/10485 +- nucleus_hipsc_train/42/111415/10486 +- nucleus_hipsc_train/42/111426/10473 +- nucleus_hipsc_train/42/111892/10724 +- nucleus_hipsc_train/42/112084/15061 +- nucleus_hipsc_train/42/112085/16293 +- nucleus_hipsc_train/42/112280/15454 +- nucleus_hipsc_train/42/112565/10904 +- nucleus_hipsc_train/42/112758/16064 +- nucleus_hipsc_train/42/112772/14973 +- nucleus_hipsc_train/42/113432/11852 +- nucleus_hipsc_train/42/113634/10939 +- nucleus_hipsc_train/42/113921/11053 +- nucleus_hipsc_train/42/114209/10977 +- nucleus_hipsc_train/42/114212/10981 +- nucleus_hipsc_train/42/114787/11121 +- nucleus_hipsc_train/42/114788/11097 +- nucleus_hipsc_train/42/114965/11232 +- nucleus_hipsc_train/42/114965/11269 +- nucleus_hipsc_train/42/114979/11222 +- nucleus_hipsc_train/42/115160/12126 +- nucleus_hipsc_train/42/115169/16617 +- nucleus_hipsc_train/42/115349/11410 +- nucleus_hipsc_train/42/115541/15346 +- nucleus_hipsc_train/42/115542/16879 +- nucleus_hipsc_train/42/115552/15185 +- nucleus_hipsc_train/42/115554/15716 +- nucleus_hipsc_train/42/115555/16425 +- nucleus_hipsc_train/42/115556/15703 +- nucleus_hipsc_train/42/115831/11479 +- nucleus_hipsc_train/42/116034/11497 +- nucleus_hipsc_train/42/116309/11595 +- nucleus_hipsc_train/42/116324/11616 +- nucleus_hipsc_train/42/116608/10515 +- nucleus_hipsc_train/42/116608/10614 +- nucleus_hipsc_train/42/116887/10440 +- nucleus_hipsc_train/42/116897/10412 +- nucleus_hipsc_train/42/116900/10422 +- nucleus_hipsc_train/42/117173/10673 +- nucleus_hipsc_train/42/117186/10657 +- nucleus_hipsc_train/42/117557/11347 +- nucleus_hipsc_train/42/117559/11367 +- nucleus_hipsc_train/42/117572/11385 +- nucleus_hipsc_train/42/117847/11299 +- nucleus_hipsc_train/42/118420/11731 +- nucleus_hipsc_train/42/118423/11658 +- nucleus_hipsc_train/42/118712/11569 +- nucleus_hipsc_train/42/118806/11804 +- nucleus_hipsc_train/42/118808/11800 +- nucleus_hipsc_train/42/121791/16666 +- nucleus_hipsc_train/42/121793/15852 +- nucleus_hipsc_train/42/121806/15946 +- nucleus_hipsc_train/42/123328/15550 +- nucleus_hipsc_train/42/123328/17092 +- nucleus_hipsc_train/42/123714/16851 +- nucleus_hipsc_train/42/123903/15431 +- nucleus_hipsc_train/42/124002/16132 +- nucleus_hipsc_train/42/124014/16885 +- nucleus_hipsc_train/42/124205/15565 +- nucleus_hipsc_train/42/124287/15382 +- nucleus_hipsc_train/42/124290/15483 +- nucleus_hipsc_train/42/124291/15731 +- nucleus_hipsc_train/42/124299/16712 +- nucleus_hipsc_train/42/124301/15843 +- nucleus_hipsc_train/42/127171/12333 +- nucleus_hipsc_train/42/127647/12252 +- nucleus_hipsc_train/42/127648/12223 +- nucleus_hipsc_train/42/127649/12208 +- nucleus_hipsc_train/42/127650/12238 +- nucleus_hipsc_train/42/127650/12256 +- nucleus_hipsc_train/42/127651/12217 +- nucleus_hipsc_train/42/127651/12239 +- nucleus_hipsc_train/42/127852/12320 +- nucleus_hipsc_train/42/127935/12457 +- nucleus_hipsc_train/42/127947/12485 +- nucleus_hipsc_train/42/128416/12512 +- nucleus_hipsc_train/42/128514/12657 +- nucleus_hipsc_train/42/128514/12667 +- nucleus_hipsc_train/42/128525/12654 +- nucleus_hipsc_train/42/128715/12598 +- nucleus_hipsc_train/42/128718/12626 +- nucleus_hipsc_train/42/128719/12625 +- nucleus_hipsc_train/42/129473/12830 +- nucleus_hipsc_train/42/129473/12852 +- nucleus_hipsc_train/42/129571/12811 +- nucleus_hipsc_train/42/129583/12802 +- nucleus_hipsc_train/42/129774/12715 +- nucleus_hipsc_train/42/129855/12931 +- nucleus_hipsc_train/42/130155/13043 +- nucleus_hipsc_train/42/130527/12960 +- nucleus_hipsc_train/42/130625/16186 +- nucleus_hipsc_train/42/130707/13231 +- nucleus_hipsc_train/42/130722/17097 +- nucleus_hipsc_train/42/132173/13409 +- nucleus_hipsc_train/42/132175/13365 +- nucleus_hipsc_train/42/132653/13278 +- nucleus_hipsc_train/42/132831/13415 +- nucleus_hipsc_train/42/132844/13432 +- nucleus_hipsc_train/42/132845/13448 +- nucleus_hipsc_train/42/132929/13513 +- nucleus_hipsc_train/42/133133/13640 +- nucleus_hipsc_train/42/133323/13465 +- nucleus_hipsc_train/42/133324/13457 +- nucleus_hipsc_train/42/133325/13497 +- nucleus_hipsc_train/42/133503/13577 +- nucleus_hipsc_train/42/133504/13572 +- nucleus_hipsc_train/42/133602/13711 +- nucleus_hipsc_train/42/133711/13788 +- nucleus_hipsc_train/42/134272/13918 +- nucleus_hipsc_train/42/134286/13916 +- nucleus_hipsc_train/42/134656/13884 +- nucleus_hipsc_train/42/135272/14059 +- nucleus_hipsc_train/42/135440/14128 +- nucleus_hipsc_train/42/135525/14245 +- nucleus_hipsc_train/42/135614/14178 +- nucleus_hipsc_train/42/137434/14771 +- nucleus_hipsc_train/42/137464/14708 +- nucleus_hipsc_train/42/137767/14413 +- nucleus_hipsc_train/42/137772/14516 +- nucleus_hipsc_train/42/137956/15501 +- nucleus_hipsc_train/42/137956/16613 +- nucleus_hipsc_train/42/137956/17196 +- nucleus_hipsc_train/42/137956/17224 +- nucleus_hipsc_train/42/138024/15890 +- nucleus_hipsc_train/42/138028/16174 +- nucleus_hipsc_train/42/138032/15577 +- nucleus_hipsc_train/42/138261/16083 +- nucleus_hipsc_train/42/77912/9479 +- nucleus_hipsc_train/42/77912/9520 +- nucleus_hipsc_train/42/77923/9543 +- nucleus_hipsc_train/42/78389/9675 +- nucleus_hipsc_train/42/78391/9672 +- nucleus_hipsc_train/42/78487/9750 +- nucleus_hipsc_train/42/78487/9758 +- nucleus_hipsc_train/42/78691/9802 +- nucleus_hipsc_train/42/79541/9897 +- nucleus_hipsc_train/42/79552/9894 +- nucleus_hipsc_train/42/79554/9874 +- nucleus_hipsc_train/42/79828/9972 +- nucleus_hipsc_train/42/79831/9969 +- nucleus_hipsc_train/42/79832/9978 +- nucleus_hipsc_train/42/79841/9963 +- nucleus_hipsc_train/42/80023/15006 +- nucleus_hipsc_train/42/80033/15189 +- nucleus_hipsc_train/42/80035/9980 +- nucleus_hipsc_train/42/80224/9960 +- nucleus_hipsc_train/42/83392/9630 +test_fovs: +- nucleus_hipsc_test/4/11393/1428 +- nucleus_hipsc_test/4/11479/1481 +- nucleus_hipsc_test/4/18007/1641 +- nucleus_hipsc_test/4/18102/1710 +- nucleus_hipsc_test/4/18485/1842 +- nucleus_hipsc_test/4/22901/3306 +- nucleus_hipsc_test/4/27797/2857 +- nucleus_hipsc_test/4/28759/3400 +- nucleus_hipsc_test/4/29060/3786 +- nucleus_hipsc_test/4/29140/3687 +- nucleus_hipsc_test/4/29334/3890 +- nucleus_hipsc_test/4/30293/3915 +- nucleus_hipsc_test/4/31736/15232 +- nucleus_hipsc_test/4/32024/4089 +- nucleus_hipsc_test/4/34998/4271 +- nucleus_hipsc_test/4/35284/4501 +- nucleus_hipsc_test/4/36643/4930 +- nucleus_hipsc_test/4/37601/5175 +- nucleus_hipsc_test/4/38464/5176 +- nucleus_hipsc_test/4/4556/15828 +- nucleus_hipsc_test/4/4556/16242 +- nucleus_hipsc_test/4/5910/824 +- nucleus_hipsc_test/4/6497/1014 +- nucleus_hipsc_test/4/6775/1242 +- nucleus_hipsc_test/4/8706/1138 +- nucleus_hipsc_test/4/94507/699 +- nucleus_hipsc_test/41/44212/5751 +- nucleus_hipsc_test/41/48436/5515 +- nucleus_hipsc_test/41/48536/5593 +- nucleus_hipsc_test/41/49121/5716 +- nucleus_hipsc_test/41/49121/5777 +- nucleus_hipsc_test/41/49204/5680 +- nucleus_hipsc_test/41/49888/5888 +- nucleus_hipsc_test/41/49975/5926 +- nucleus_hipsc_test/41/50548/6016 +- nucleus_hipsc_test/41/52564/5966 +- nucleus_hipsc_test/41/53048/15203 +- nucleus_hipsc_test/41/55160/6367 +- nucleus_hipsc_test/41/55348/6437 +- nucleus_hipsc_test/41/55350/6427 +- nucleus_hipsc_test/41/58326/6874 +- nucleus_hipsc_test/41/58517/6781 +- nucleus_hipsc_test/41/60728/7413 +- nucleus_hipsc_test/41/62754/7076 +- nucleus_hipsc_test/41/63524/7359 +- nucleus_hipsc_test/41/63524/7400 +- nucleus_hipsc_test/41/63713/7287 +- nucleus_hipsc_test/41/66020/7541 +- nucleus_hipsc_test/41/67168/7688 +- nucleus_hipsc_test/41/68116/7831 +- nucleus_hipsc_test/41/68598/9132 +- nucleus_hipsc_test/41/68804/8999 +- nucleus_hipsc_test/41/68884/9247 +- nucleus_hipsc_test/41/68885/9316 +- nucleus_hipsc_test/41/70240/9487 +- nucleus_hipsc_test/41/72356/7974 +- nucleus_hipsc_test/41/72629/8071 +- nucleus_hipsc_test/41/72725/8138 +- nucleus_hipsc_test/41/72727/8125 +- nucleus_hipsc_test/41/73112/8476 +- nucleus_hipsc_test/41/73304/8259 +- nucleus_hipsc_test/41/73686/8660 +- nucleus_hipsc_test/41/73686/8668 +- nucleus_hipsc_test/41/73783/8567 +- nucleus_hipsc_test/41/74264/8751 +- nucleus_hipsc_test/41/74272/8740 +- nucleus_hipsc_test/41/74356/8919 +- nucleus_hipsc_test/41/75800/8019 +- nucleus_hipsc_test/41/75808/7975 +- nucleus_hipsc_test/42/107478/10817 +- nucleus_hipsc_test/42/114584/12053 +- nucleus_hipsc_test/42/115556/15421 +- nucleus_hipsc_test/42/116598/10604 +- nucleus_hipsc_test/42/117557/11343 +- nucleus_hipsc_test/42/118901/11674 +- nucleus_hipsc_test/42/118912/11694 +- nucleus_hipsc_test/42/123916/16655 +- nucleus_hipsc_test/42/124001/16229 +- nucleus_hipsc_test/42/127171/12338 +- nucleus_hipsc_test/42/127276/23725 +- nucleus_hipsc_test/42/127939/12482 +- nucleus_hipsc_test/42/128428/12536 +- nucleus_hipsc_test/42/128523/12637 +- nucleus_hipsc_test/42/129665/12780 +- nucleus_hipsc_test/42/129855/12890 +- nucleus_hipsc_test/42/132463/13304 +- nucleus_hipsc_test/42/132834/13446 +- nucleus_hipsc_test/42/133599/13746 +- nucleus_hipsc_test/42/135439/14132 +- nucleus_hipsc_test/42/137449/14744 +- nucleus_hipsc_test/42/137455/14731 +- nucleus_hipsc_test/42/137460/14685 +- nucleus_hipsc_test/42/137582/14642 +- nucleus_hipsc_test/42/137774/14522 +- nucleus_hipsc_test/42/137820/14488 +- nucleus_hipsc_test/42/137953/15518 +- nucleus_hipsc_test/42/77924/9512 +- nucleus_hipsc_test/42/80023/9994 +- nucleus_hipsc_test/42/82708/16181 +- nucleus_hipsc_test/42/84449/15422 diff --git a/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/nucleus_joint_all_v1.yaml b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/nucleus_joint_all_v1.yaml new file mode 100644 index 000000000..dc9981555 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/nucleus_joint_all_v1.yaml @@ -0,0 +1,941 @@ +name: nucleus_joint_all_v1 +description: Joint frozen benchmark collection across 2 selectors covering targets + 'h2b', 'nucleus'. Channels and FOV membership captured from the live train/test + zarr stores at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-27T12:02:35.822792+00:00' + created_by: Alex Kalinin +experiments: +- name: nucleus_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Nuclei + organelle: nucleus + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: nucleus_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Nuclei + organelle: nucleus + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: h2b_a549_mantis_2026_03_26_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2026_03_26_A549_CAAX_H2B_DENV_ZIKV/train/H2B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: H2B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: H2B + organelle: nucleus + pixel_size_xy_um: 0.116 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: h2b_a549_mantis_2026_03_26_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2026_03_26_A549_CAAX_H2B_DENV_ZIKV/test/H2B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: H2B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: H2B + organelle: nucleus + pixel_size_xy_um: 0.116 + pixel_size_z_um: 0.174 + exclude_fovs: [] +train_fovs: +- nucleus_hipsc_train/4/10615/1304 +- nucleus_hipsc_train/4/10625/1347 +- nucleus_hipsc_train/4/10900/1427 +- nucleus_hipsc_train/4/10904/1436 +- nucleus_hipsc_train/4/11384/1404 +- nucleus_hipsc_train/4/11478/1468 +- nucleus_hipsc_train/4/11490/1466 +- nucleus_hipsc_train/4/11492/1467 +- nucleus_hipsc_train/4/11573/1414 +- nucleus_hipsc_train/4/136707/16750 +- nucleus_hipsc_train/4/136710/15363 +- nucleus_hipsc_train/4/136721/16107 +- nucleus_hipsc_train/4/136725/15834 +- nucleus_hipsc_train/4/13974/1528 +- nucleus_hipsc_train/4/14646/1871 +- nucleus_hipsc_train/4/14740/1745 +- nucleus_hipsc_train/4/14742/1791 +- nucleus_hipsc_train/4/14754/1781 +- nucleus_hipsc_train/4/1493/268 +- nucleus_hipsc_train/4/1508/255 +- nucleus_hipsc_train/4/16278/2186 +- nucleus_hipsc_train/4/16376/2374 +- nucleus_hipsc_train/4/16468/2321 +- nucleus_hipsc_train/4/16469/2337 +- nucleus_hipsc_train/4/16469/2339 +- nucleus_hipsc_train/4/16469/2345 +- nucleus_hipsc_train/4/16471/2265 +- nucleus_hipsc_train/4/16472/2312 +- nucleus_hipsc_train/4/16951/2459 +- nucleus_hipsc_train/4/16951/2480 +- nucleus_hipsc_train/4/16952/2494 +- nucleus_hipsc_train/4/17333/2710 +- nucleus_hipsc_train/4/17348/16148 +- nucleus_hipsc_train/4/17525/2811 +- nucleus_hipsc_train/4/17526/2752 +- nucleus_hipsc_train/4/17536/2773 +- nucleus_hipsc_train/4/18020/1618 +- nucleus_hipsc_train/4/18020/1625 +- nucleus_hipsc_train/4/18020/1638 +- nucleus_hipsc_train/4/18487/1811 +- nucleus_hipsc_train/4/19351/1905 +- nucleus_hipsc_train/4/19543/2105 +- nucleus_hipsc_train/4/19554/2020 +- nucleus_hipsc_train/4/19556/2089 +- nucleus_hipsc_train/4/20416/2223 +- nucleus_hipsc_train/4/20596/2406 +- nucleus_hipsc_train/4/20597/2395 +- nucleus_hipsc_train/4/20597/2401 +- nucleus_hipsc_train/4/20599/2373 +- nucleus_hipsc_train/4/21077/2254 +- nucleus_hipsc_train/4/21089/2293 +- nucleus_hipsc_train/4/21556/2491 +- nucleus_hipsc_train/4/21557/2483 +- nucleus_hipsc_train/4/21557/2527 +- nucleus_hipsc_train/4/21653/2547 +- nucleus_hipsc_train/4/21860/15671 +- nucleus_hipsc_train/4/21940/2736 +- nucleus_hipsc_train/4/21943/2717 +- nucleus_hipsc_train/4/21953/2739 +- nucleus_hipsc_train/4/22133/2826 +- nucleus_hipsc_train/4/22136/2827 +- nucleus_hipsc_train/4/22339/3095 +- nucleus_hipsc_train/4/22340/3097 +- nucleus_hipsc_train/4/22612/2915 +- nucleus_hipsc_train/4/22614/2923 +- nucleus_hipsc_train/4/22615/2978 +- nucleus_hipsc_train/4/22624/2909 +- nucleus_hipsc_train/4/22709/3070 +- nucleus_hipsc_train/4/22712/3090 +- nucleus_hipsc_train/4/22913/3301 +- nucleus_hipsc_train/4/22914/3289 +- nucleus_hipsc_train/4/23380/3237 +- nucleus_hipsc_train/4/23392/3212 +- nucleus_hipsc_train/4/23395/3223 +- nucleus_hipsc_train/4/23574/3492 +- nucleus_hipsc_train/4/23764/3409 +- nucleus_hipsc_train/4/24152/3567 +- nucleus_hipsc_train/4/24724/3661 +- nucleus_hipsc_train/4/24727/3659 +- nucleus_hipsc_train/4/24928/3585 +- nucleus_hipsc_train/4/25784/3851 +- nucleus_hipsc_train/4/27800/2883 +- nucleus_hipsc_train/4/27896/2943 +- nucleus_hipsc_train/4/27992/3020 +- nucleus_hipsc_train/4/28084/3214 +- nucleus_hipsc_train/4/28084/3270 +- nucleus_hipsc_train/4/28087/3266 +- nucleus_hipsc_train/4/28756/3381 +- nucleus_hipsc_train/4/28759/3393 +- nucleus_hipsc_train/4/29045/3764 +- nucleus_hipsc_train/4/29060/3753 +- nucleus_hipsc_train/4/29143/3667 +- nucleus_hipsc_train/4/29155/3710 +- nucleus_hipsc_train/4/2932/230 +- nucleus_hipsc_train/4/29333/3908 +- nucleus_hipsc_train/4/2945/173 +- nucleus_hipsc_train/4/30292/14379 +- nucleus_hipsc_train/4/30293/3905 +- nucleus_hipsc_train/4/30308/3869 +- nucleus_hipsc_train/4/30388/16862 +- nucleus_hipsc_train/4/30389/15342 +- nucleus_hipsc_train/4/30392/16741 +- nucleus_hipsc_train/4/31732/17059 +- nucleus_hipsc_train/4/31744/16779 +- nucleus_hipsc_train/4/31841/3962 +- nucleus_hipsc_train/4/31939/3975 +- nucleus_hipsc_train/4/32024/4077 +- nucleus_hipsc_train/4/32033/4111 +- nucleus_hipsc_train/4/32033/4121 +- nucleus_hipsc_train/4/32035/4099 +- nucleus_hipsc_train/4/33077/4379 +- nucleus_hipsc_train/4/33572/4229 +- nucleus_hipsc_train/4/33942/15337 +- nucleus_hipsc_train/4/33942/16205 +- nucleus_hipsc_train/4/33943/17061 +- nucleus_hipsc_train/4/33953/16561 +- nucleus_hipsc_train/4/33955/16023 +- nucleus_hipsc_train/4/34038/4363 +- nucleus_hipsc_train/4/34808/4417 +- nucleus_hipsc_train/4/35000/4274 +- nucleus_hipsc_train/4/35284/4472 +- nucleus_hipsc_train/4/35287/4460 +- nucleus_hipsc_train/4/35479/4551 +- nucleus_hipsc_train/4/35489/4583 +- nucleus_hipsc_train/4/36449/15327 +- nucleus_hipsc_train/4/36544/4909 +- nucleus_hipsc_train/4/36544/4931 +- nucleus_hipsc_train/4/36628/4907 +- nucleus_hipsc_train/4/36836/4996 +- nucleus_hipsc_train/4/37591/5133 +- nucleus_hipsc_train/4/37603/5147 +- nucleus_hipsc_train/4/37972/5388 +- nucleus_hipsc_train/4/37988/5373 +- nucleus_hipsc_train/4/40084/5359 +- nucleus_hipsc_train/4/40086/5362 +- nucleus_hipsc_train/4/40376/4584 +- nucleus_hipsc_train/4/40385/4614 +- nucleus_hipsc_train/4/40386/4613 +- nucleus_hipsc_train/4/40387/4586 +- nucleus_hipsc_train/4/40483/4619 +- nucleus_hipsc_train/4/40483/4621 +- nucleus_hipsc_train/4/40960/4654 +- nucleus_hipsc_train/4/41044/4851 +- nucleus_hipsc_train/4/41047/4885 +- nucleus_hipsc_train/4/41237/4861 +- nucleus_hipsc_train/4/41249/4835 +- nucleus_hipsc_train/4/41912/5074 +- nucleus_hipsc_train/4/5143/954 +- nucleus_hipsc_train/4/5236/869 +- nucleus_hipsc_train/4/5238/875 +- nucleus_hipsc_train/4/6485/1018 +- nucleus_hipsc_train/4/6486/992 +- nucleus_hipsc_train/4/6497/1003 +- nucleus_hipsc_train/4/6775/1203 +- nucleus_hipsc_train/4/6775/1226 +- nucleus_hipsc_train/4/6775/1236 +- nucleus_hipsc_train/4/7156/1124 +- nucleus_hipsc_train/4/7349/1355 +- nucleus_hipsc_train/4/7650/1278 +- nucleus_hipsc_train/4/8214/878 +- nucleus_hipsc_train/4/8214/879 +- nucleus_hipsc_train/4/8228/898 +- nucleus_hipsc_train/4/8695/1215 +- nucleus_hipsc_train/4/88267/15294 +- nucleus_hipsc_train/4/89048/356 +- nucleus_hipsc_train/4/8982/1171 +- nucleus_hipsc_train/4/90088/415 +- nucleus_hipsc_train/4/90858/15658 +- nucleus_hipsc_train/4/90858/16534 +- nucleus_hipsc_train/4/91144/102 +- nucleus_hipsc_train/4/91924/458 +- nucleus_hipsc_train/4/93448/596 +- nucleus_hipsc_train/4/94312/684 +- nucleus_hipsc_train/4/95752/811 +- nucleus_hipsc_train/4/95753/737 +- nucleus_hipsc_train/4/95753/872 +- nucleus_hipsc_train/41/43638/5246 +- nucleus_hipsc_train/41/43639/5265 +- nucleus_hipsc_train/41/43732/16519 +- nucleus_hipsc_train/41/45556/5706 +- nucleus_hipsc_train/41/45556/5734 +- nucleus_hipsc_train/41/45559/5714 +- nucleus_hipsc_train/41/48436/5507 +- nucleus_hipsc_train/41/48534/5575 +- nucleus_hipsc_train/41/48535/5623 +- nucleus_hipsc_train/41/48548/5574 +- nucleus_hipsc_train/41/48548/5589 +- nucleus_hipsc_train/41/49204/5661 +- nucleus_hipsc_train/41/49220/5671 +- nucleus_hipsc_train/41/49698/5819 +- nucleus_hipsc_train/41/49972/5933 +- nucleus_hipsc_train/41/49973/5960 +- nucleus_hipsc_train/41/50263/6077 +- nucleus_hipsc_train/41/50263/6082 +- nucleus_hipsc_train/41/50356/15510 +- nucleus_hipsc_train/41/50356/15578 +- nucleus_hipsc_train/41/50359/15457 +- nucleus_hipsc_train/41/50548/6024 +- nucleus_hipsc_train/41/50551/6022 +- nucleus_hipsc_train/41/53044/15243 +- nucleus_hipsc_train/41/53046/16965 +- nucleus_hipsc_train/41/53428/6238 +- nucleus_hipsc_train/41/53524/15636 +- nucleus_hipsc_train/41/53538/15395 +- nucleus_hipsc_train/41/53731/15920 +- nucleus_hipsc_train/41/55156/6355 +- nucleus_hipsc_train/41/55156/6358 +- nucleus_hipsc_train/41/55158/6324 +- nucleus_hipsc_train/41/55158/6353 +- nucleus_hipsc_train/41/55253/6499 +- nucleus_hipsc_train/41/55256/6482 +- nucleus_hipsc_train/41/55351/6419 +- nucleus_hipsc_train/41/55363/6362 +- nucleus_hipsc_train/41/55925/6584 +- nucleus_hipsc_train/41/56406/6643 +- nucleus_hipsc_train/41/56416/6614 +- nucleus_hipsc_train/41/56418/6626 +- nucleus_hipsc_train/41/56419/6630 +- nucleus_hipsc_train/41/56596/6678 +- nucleus_hipsc_train/41/56896/7720 +- nucleus_hipsc_train/41/57364/6456 +- nucleus_hipsc_train/41/57365/6428 +- nucleus_hipsc_train/41/57367/6430 +- nucleus_hipsc_train/41/57464/6544 +- nucleus_hipsc_train/41/57472/6556 +- nucleus_hipsc_train/41/57472/6565 +- nucleus_hipsc_train/41/58134/6821 +- nucleus_hipsc_train/41/58326/6840 +- nucleus_hipsc_train/41/58420/6971 +- nucleus_hipsc_train/41/58423/6963 +- nucleus_hipsc_train/41/58518/6786 +- nucleus_hipsc_train/41/59285/7118 +- nucleus_hipsc_train/41/59285/7124 +- nucleus_hipsc_train/41/59298/7175 +- nucleus_hipsc_train/41/59380/7015 +- nucleus_hipsc_train/41/59479/7188 +- nucleus_hipsc_train/41/59479/7200 +- nucleus_hipsc_train/41/59480/7179 +- nucleus_hipsc_train/41/60548/7475 +- nucleus_hipsc_train/41/60632/7345 +- nucleus_hipsc_train/41/60726/7399 +- nucleus_hipsc_train/41/60737/7332 +- nucleus_hipsc_train/41/60738/7414 +- nucleus_hipsc_train/41/62740/7068 +- nucleus_hipsc_train/41/62932/6916 +- nucleus_hipsc_train/41/63508/7389 +- nucleus_hipsc_train/41/63523/7383 +- nucleus_hipsc_train/41/63608/7462 +- nucleus_hipsc_train/41/63608/7464 +- nucleus_hipsc_train/41/63620/7451 +- nucleus_hipsc_train/41/63701/7283 +- nucleus_hipsc_train/41/63713/7256 +- nucleus_hipsc_train/41/66292/7775 +- nucleus_hipsc_train/41/66292/7782 +- nucleus_hipsc_train/41/66292/7796 +- nucleus_hipsc_train/41/66296/7788 +- nucleus_hipsc_train/41/67157/7690 +- nucleus_hipsc_train/41/67168/7678 +- nucleus_hipsc_train/41/68131/7834 +- nucleus_hipsc_train/41/68503/9206 +- nucleus_hipsc_train/41/68504/9176 +- nucleus_hipsc_train/41/68504/9197 +- nucleus_hipsc_train/41/68512/9188 +- nucleus_hipsc_train/41/68512/9207 +- nucleus_hipsc_train/41/68512/9212 +- nucleus_hipsc_train/41/68708/9065 +- nucleus_hipsc_train/41/68788/9030 +- nucleus_hipsc_train/41/68800/9019 +- nucleus_hipsc_train/41/69472/9285 +- nucleus_hipsc_train/41/69473/9279 +- nucleus_hipsc_train/41/69474/9306 +- nucleus_hipsc_train/41/70052/15689 +- nucleus_hipsc_train/41/70231/9525 +- nucleus_hipsc_train/41/70232/9551 +- nucleus_hipsc_train/41/72244/8037 +- nucleus_hipsc_train/41/72244/8074 +- nucleus_hipsc_train/41/72256/8049 +- nucleus_hipsc_train/41/72260/8085 +- nucleus_hipsc_train/41/72342/7994 +- nucleus_hipsc_train/41/72356/7962 +- nucleus_hipsc_train/41/72628/8109 +- nucleus_hipsc_train/41/72629/8086 +- nucleus_hipsc_train/41/72630/8119 +- nucleus_hipsc_train/41/72631/8095 +- nucleus_hipsc_train/41/72725/8151 +- nucleus_hipsc_train/41/72726/8128 +- nucleus_hipsc_train/41/72834/8288 +- nucleus_hipsc_train/41/73300/8255 +- nucleus_hipsc_train/41/73396/8265 +- nucleus_hipsc_train/41/73397/8271 +- nucleus_hipsc_train/41/73398/8307 +- nucleus_hipsc_train/41/73495/8186 +- nucleus_hipsc_train/41/73507/8203 +- nucleus_hipsc_train/41/73685/8634 +- nucleus_hipsc_train/41/73687/8628 +- nucleus_hipsc_train/41/73700/8663 +- nucleus_hipsc_train/41/73782/8525 +- nucleus_hipsc_train/41/73782/8576 +- nucleus_hipsc_train/41/73783/8530 +- nucleus_hipsc_train/41/73784/8543 +- nucleus_hipsc_train/41/73879/15995 +- nucleus_hipsc_train/41/73975/15832 +- nucleus_hipsc_train/41/74165/8821 +- nucleus_hipsc_train/41/74168/8793 +- nucleus_hipsc_train/41/74260/8727 +- nucleus_hipsc_train/41/74273/8721 +- nucleus_hipsc_train/41/74371/8941 +- nucleus_hipsc_train/41/74371/8978 +- nucleus_hipsc_train/41/75042/7915 +- nucleus_hipsc_train/41/75124/16978 +- nucleus_hipsc_train/41/75125/16693 +- nucleus_hipsc_train/41/75512/7872 +- nucleus_hipsc_train/41/75796/7941 +- nucleus_hipsc_train/41/75799/7953 +- nucleus_hipsc_train/41/76000/8244 +- nucleus_hipsc_train/41/77250/8868 +- nucleus_hipsc_train/41/77333/9094 +- nucleus_hipsc_train/42/106420/10373 +- nucleus_hipsc_train/42/106421/10380 +- nucleus_hipsc_train/42/106422/10368 +- nucleus_hipsc_train/42/106516/10272 +- nucleus_hipsc_train/42/106518/10239 +- nucleus_hipsc_train/42/106520/10262 +- nucleus_hipsc_train/42/106915/10747 +- nucleus_hipsc_train/42/106996/10652 +- nucleus_hipsc_train/42/106998/10641 +- nucleus_hipsc_train/42/107480/10815 +- nucleus_hipsc_train/42/107480/10822 +- nucleus_hipsc_train/42/107572/12022 +- nucleus_hipsc_train/42/107574/11982 +- nucleus_hipsc_train/42/107574/12039 +- nucleus_hipsc_train/42/107682/11895 +- nucleus_hipsc_train/42/107682/11898 +- nucleus_hipsc_train/42/107684/11928 +- nucleus_hipsc_train/42/107956/11969 +- nucleus_hipsc_train/42/107956/11981 +- nucleus_hipsc_train/42/107958/11911 +- nucleus_hipsc_train/42/107959/12029 +- nucleus_hipsc_train/42/107972/11941 +- nucleus_hipsc_train/42/108148/15673 +- nucleus_hipsc_train/42/108149/12190 +- nucleus_hipsc_train/42/108246/11135 +- nucleus_hipsc_train/42/108248/16355 +- nucleus_hipsc_train/42/108824/15581 +- nucleus_hipsc_train/42/108833/15155 +- nucleus_hipsc_train/42/110548/10130 +- nucleus_hipsc_train/42/110552/10154 +- nucleus_hipsc_train/42/110552/10175 +- nucleus_hipsc_train/42/110645/10108 +- nucleus_hipsc_train/42/110646/10124 +- nucleus_hipsc_train/42/110660/10091 +- nucleus_hipsc_train/42/110947/10199 +- nucleus_hipsc_train/42/111125/10242 +- nucleus_hipsc_train/42/111413/10485 +- nucleus_hipsc_train/42/111415/10486 +- nucleus_hipsc_train/42/111426/10473 +- nucleus_hipsc_train/42/111892/10724 +- nucleus_hipsc_train/42/112084/15061 +- nucleus_hipsc_train/42/112085/16293 +- nucleus_hipsc_train/42/112280/15454 +- nucleus_hipsc_train/42/112565/10904 +- nucleus_hipsc_train/42/112758/16064 +- nucleus_hipsc_train/42/112772/14973 +- nucleus_hipsc_train/42/113432/11852 +- nucleus_hipsc_train/42/113634/10939 +- nucleus_hipsc_train/42/113921/11053 +- nucleus_hipsc_train/42/114209/10977 +- nucleus_hipsc_train/42/114212/10981 +- nucleus_hipsc_train/42/114787/11121 +- nucleus_hipsc_train/42/114788/11097 +- nucleus_hipsc_train/42/114965/11232 +- nucleus_hipsc_train/42/114965/11269 +- nucleus_hipsc_train/42/114979/11222 +- nucleus_hipsc_train/42/115160/12126 +- nucleus_hipsc_train/42/115169/16617 +- nucleus_hipsc_train/42/115349/11410 +- nucleus_hipsc_train/42/115541/15346 +- nucleus_hipsc_train/42/115542/16879 +- nucleus_hipsc_train/42/115552/15185 +- nucleus_hipsc_train/42/115554/15716 +- nucleus_hipsc_train/42/115555/16425 +- nucleus_hipsc_train/42/115556/15703 +- nucleus_hipsc_train/42/115831/11479 +- nucleus_hipsc_train/42/116034/11497 +- nucleus_hipsc_train/42/116309/11595 +- nucleus_hipsc_train/42/116324/11616 +- nucleus_hipsc_train/42/116608/10515 +- nucleus_hipsc_train/42/116608/10614 +- nucleus_hipsc_train/42/116887/10440 +- nucleus_hipsc_train/42/116897/10412 +- nucleus_hipsc_train/42/116900/10422 +- nucleus_hipsc_train/42/117173/10673 +- nucleus_hipsc_train/42/117186/10657 +- nucleus_hipsc_train/42/117557/11347 +- nucleus_hipsc_train/42/117559/11367 +- nucleus_hipsc_train/42/117572/11385 +- nucleus_hipsc_train/42/117847/11299 +- nucleus_hipsc_train/42/118420/11731 +- nucleus_hipsc_train/42/118423/11658 +- nucleus_hipsc_train/42/118712/11569 +- nucleus_hipsc_train/42/118806/11804 +- nucleus_hipsc_train/42/118808/11800 +- nucleus_hipsc_train/42/121791/16666 +- nucleus_hipsc_train/42/121793/15852 +- nucleus_hipsc_train/42/121806/15946 +- nucleus_hipsc_train/42/123328/15550 +- nucleus_hipsc_train/42/123328/17092 +- nucleus_hipsc_train/42/123714/16851 +- nucleus_hipsc_train/42/123903/15431 +- nucleus_hipsc_train/42/124002/16132 +- nucleus_hipsc_train/42/124014/16885 +- nucleus_hipsc_train/42/124205/15565 +- nucleus_hipsc_train/42/124287/15382 +- nucleus_hipsc_train/42/124290/15483 +- nucleus_hipsc_train/42/124291/15731 +- nucleus_hipsc_train/42/124299/16712 +- nucleus_hipsc_train/42/124301/15843 +- nucleus_hipsc_train/42/127171/12333 +- nucleus_hipsc_train/42/127647/12252 +- nucleus_hipsc_train/42/127648/12223 +- nucleus_hipsc_train/42/127649/12208 +- nucleus_hipsc_train/42/127650/12238 +- nucleus_hipsc_train/42/127650/12256 +- nucleus_hipsc_train/42/127651/12217 +- nucleus_hipsc_train/42/127651/12239 +- nucleus_hipsc_train/42/127852/12320 +- nucleus_hipsc_train/42/127935/12457 +- nucleus_hipsc_train/42/127947/12485 +- nucleus_hipsc_train/42/128416/12512 +- nucleus_hipsc_train/42/128514/12657 +- nucleus_hipsc_train/42/128514/12667 +- nucleus_hipsc_train/42/128525/12654 +- nucleus_hipsc_train/42/128715/12598 +- nucleus_hipsc_train/42/128718/12626 +- nucleus_hipsc_train/42/128719/12625 +- nucleus_hipsc_train/42/129473/12830 +- nucleus_hipsc_train/42/129473/12852 +- nucleus_hipsc_train/42/129571/12811 +- nucleus_hipsc_train/42/129583/12802 +- nucleus_hipsc_train/42/129774/12715 +- nucleus_hipsc_train/42/129855/12931 +- nucleus_hipsc_train/42/130155/13043 +- nucleus_hipsc_train/42/130527/12960 +- nucleus_hipsc_train/42/130625/16186 +- nucleus_hipsc_train/42/130707/13231 +- nucleus_hipsc_train/42/130722/17097 +- nucleus_hipsc_train/42/132173/13409 +- nucleus_hipsc_train/42/132175/13365 +- nucleus_hipsc_train/42/132653/13278 +- nucleus_hipsc_train/42/132831/13415 +- nucleus_hipsc_train/42/132844/13432 +- nucleus_hipsc_train/42/132845/13448 +- nucleus_hipsc_train/42/132929/13513 +- nucleus_hipsc_train/42/133133/13640 +- nucleus_hipsc_train/42/133323/13465 +- nucleus_hipsc_train/42/133324/13457 +- nucleus_hipsc_train/42/133325/13497 +- nucleus_hipsc_train/42/133503/13577 +- nucleus_hipsc_train/42/133504/13572 +- nucleus_hipsc_train/42/133602/13711 +- nucleus_hipsc_train/42/133711/13788 +- nucleus_hipsc_train/42/134272/13918 +- nucleus_hipsc_train/42/134286/13916 +- nucleus_hipsc_train/42/134656/13884 +- nucleus_hipsc_train/42/135272/14059 +- nucleus_hipsc_train/42/135440/14128 +- nucleus_hipsc_train/42/135525/14245 +- nucleus_hipsc_train/42/135614/14178 +- nucleus_hipsc_train/42/137434/14771 +- nucleus_hipsc_train/42/137464/14708 +- nucleus_hipsc_train/42/137767/14413 +- nucleus_hipsc_train/42/137772/14516 +- nucleus_hipsc_train/42/137956/15501 +- nucleus_hipsc_train/42/137956/16613 +- nucleus_hipsc_train/42/137956/17196 +- nucleus_hipsc_train/42/137956/17224 +- nucleus_hipsc_train/42/138024/15890 +- nucleus_hipsc_train/42/138028/16174 +- nucleus_hipsc_train/42/138032/15577 +- nucleus_hipsc_train/42/138261/16083 +- nucleus_hipsc_train/42/77912/9479 +- nucleus_hipsc_train/42/77912/9520 +- nucleus_hipsc_train/42/77923/9543 +- nucleus_hipsc_train/42/78389/9675 +- nucleus_hipsc_train/42/78391/9672 +- nucleus_hipsc_train/42/78487/9750 +- nucleus_hipsc_train/42/78487/9758 +- nucleus_hipsc_train/42/78691/9802 +- nucleus_hipsc_train/42/79541/9897 +- nucleus_hipsc_train/42/79552/9894 +- nucleus_hipsc_train/42/79554/9874 +- nucleus_hipsc_train/42/79828/9972 +- nucleus_hipsc_train/42/79831/9969 +- nucleus_hipsc_train/42/79832/9978 +- nucleus_hipsc_train/42/79841/9963 +- nucleus_hipsc_train/42/80023/15006 +- nucleus_hipsc_train/42/80033/15189 +- nucleus_hipsc_train/42/80035/9980 +- nucleus_hipsc_train/42/80224/9960 +- nucleus_hipsc_train/42/83392/9630 +- h2b_a549_mantis_2026_03_26_train/B/2/000002 +- h2b_a549_mantis_2026_03_26_train/B/2/000003 +- h2b_a549_mantis_2026_03_26_train/B/2/000005 +- h2b_a549_mantis_2026_03_26_train/B/2/000006 +- h2b_a549_mantis_2026_03_26_train/B/2/000008 +- h2b_a549_mantis_2026_03_26_train/B/2/001000 +- h2b_a549_mantis_2026_03_26_train/B/2/001001 +- h2b_a549_mantis_2026_03_26_train/B/2/001002 +- h2b_a549_mantis_2026_03_26_train/B/2/001003 +- h2b_a549_mantis_2026_03_26_train/B/2/001004 +- h2b_a549_mantis_2026_03_26_train/B/2/001005 +- h2b_a549_mantis_2026_03_26_train/B/2/001006 +- h2b_a549_mantis_2026_03_26_train/B/2/001007 +- h2b_a549_mantis_2026_03_26_train/B/2/001008 +- h2b_a549_mantis_2026_03_26_train/B/2/002000 +- h2b_a549_mantis_2026_03_26_train/B/2/002001 +- h2b_a549_mantis_2026_03_26_train/B/2/002002 +- h2b_a549_mantis_2026_03_26_train/B/2/002003 +- h2b_a549_mantis_2026_03_26_train/B/2/002004 +- h2b_a549_mantis_2026_03_26_train/B/2/002005 +- h2b_a549_mantis_2026_03_26_train/B/2/002006 +- h2b_a549_mantis_2026_03_26_train/B/2/002007 +- h2b_a549_mantis_2026_03_26_train/B/2/002008 +- h2b_a549_mantis_2026_03_26_train/B/2/003000 +- h2b_a549_mantis_2026_03_26_train/B/2/003002 +- h2b_a549_mantis_2026_03_26_train/B/2/003003 +- h2b_a549_mantis_2026_03_26_train/B/2/003005 +- h2b_a549_mantis_2026_03_26_train/B/2/003006 +- h2b_a549_mantis_2026_03_26_train/B/2/003008 +- h2b_a549_mantis_2026_03_26_train/B/2/004000 +- h2b_a549_mantis_2026_03_26_train/B/2/004001 +- h2b_a549_mantis_2026_03_26_train/B/2/004002 +- h2b_a549_mantis_2026_03_26_train/B/2/004003 +- h2b_a549_mantis_2026_03_26_train/B/2/004004 +- h2b_a549_mantis_2026_03_26_train/B/2/004005 +- h2b_a549_mantis_2026_03_26_train/B/2/004006 +- h2b_a549_mantis_2026_03_26_train/B/2/004007 +- h2b_a549_mantis_2026_03_26_train/B/2/004008 +- h2b_a549_mantis_2026_03_26_train/B/2/005000 +- h2b_a549_mantis_2026_03_26_train/B/2/005002 +- h2b_a549_mantis_2026_03_26_train/B/2/005003 +- h2b_a549_mantis_2026_03_26_train/B/2/005005 +- h2b_a549_mantis_2026_03_26_train/B/2/005006 +- h2b_a549_mantis_2026_03_26_train/B/2/005008 +- h2b_a549_mantis_2026_03_26_train/B/2/006000 +- h2b_a549_mantis_2026_03_26_train/B/2/006001 +- h2b_a549_mantis_2026_03_26_train/B/2/006002 +- h2b_a549_mantis_2026_03_26_train/B/2/006003 +- h2b_a549_mantis_2026_03_26_train/B/2/006004 +- h2b_a549_mantis_2026_03_26_train/B/2/006005 +- h2b_a549_mantis_2026_03_26_train/B/2/006006 +- h2b_a549_mantis_2026_03_26_train/B/2/006007 +- h2b_a549_mantis_2026_03_26_train/B/2/006008 +- h2b_a549_mantis_2026_03_26_train/B/2/007000 +- h2b_a549_mantis_2026_03_26_train/B/2/007001 +- h2b_a549_mantis_2026_03_26_train/B/2/007002 +- h2b_a549_mantis_2026_03_26_train/B/2/007003 +- h2b_a549_mantis_2026_03_26_train/B/2/007004 +- h2b_a549_mantis_2026_03_26_train/B/2/007005 +- h2b_a549_mantis_2026_03_26_train/B/2/007006 +- h2b_a549_mantis_2026_03_26_train/B/2/007007 +- h2b_a549_mantis_2026_03_26_train/B/2/007008 +- h2b_a549_mantis_2026_03_26_train/B/2/008000 +- h2b_a549_mantis_2026_03_26_train/B/2/008002 +- h2b_a549_mantis_2026_03_26_train/B/2/008003 +- h2b_a549_mantis_2026_03_26_train/B/2/008005 +- h2b_a549_mantis_2026_03_26_train/B/2/008006 +- h2b_a549_mantis_2026_03_26_train/B/2/008008 +- h2b_a549_mantis_2026_03_26_train/B/3/000000 +- h2b_a549_mantis_2026_03_26_train/B/3/000002 +- h2b_a549_mantis_2026_03_26_train/B/3/000003 +- h2b_a549_mantis_2026_03_26_train/B/3/000005 +- h2b_a549_mantis_2026_03_26_train/B/3/000006 +- h2b_a549_mantis_2026_03_26_train/B/3/000008 +- h2b_a549_mantis_2026_03_26_train/B/3/001000 +- h2b_a549_mantis_2026_03_26_train/B/3/001001 +- h2b_a549_mantis_2026_03_26_train/B/3/001002 +- h2b_a549_mantis_2026_03_26_train/B/3/001003 +- h2b_a549_mantis_2026_03_26_train/B/3/001004 +- h2b_a549_mantis_2026_03_26_train/B/3/001005 +- h2b_a549_mantis_2026_03_26_train/B/3/001006 +- h2b_a549_mantis_2026_03_26_train/B/3/001007 +- h2b_a549_mantis_2026_03_26_train/B/3/001008 +- h2b_a549_mantis_2026_03_26_train/B/3/002000 +- h2b_a549_mantis_2026_03_26_train/B/3/002001 +- h2b_a549_mantis_2026_03_26_train/B/3/002002 +- h2b_a549_mantis_2026_03_26_train/B/3/002003 +- h2b_a549_mantis_2026_03_26_train/B/3/002004 +- h2b_a549_mantis_2026_03_26_train/B/3/002005 +- h2b_a549_mantis_2026_03_26_train/B/3/002006 +- h2b_a549_mantis_2026_03_26_train/B/3/002007 +- h2b_a549_mantis_2026_03_26_train/B/3/002008 +- h2b_a549_mantis_2026_03_26_train/B/3/003000 +- h2b_a549_mantis_2026_03_26_train/B/3/003002 +- h2b_a549_mantis_2026_03_26_train/B/3/003003 +- h2b_a549_mantis_2026_03_26_train/B/3/003005 +- h2b_a549_mantis_2026_03_26_train/B/3/003006 +- h2b_a549_mantis_2026_03_26_train/B/3/003008 +- h2b_a549_mantis_2026_03_26_train/B/3/004000 +- h2b_a549_mantis_2026_03_26_train/B/3/004001 +- h2b_a549_mantis_2026_03_26_train/B/3/004002 +- h2b_a549_mantis_2026_03_26_train/B/3/004003 +- h2b_a549_mantis_2026_03_26_train/B/3/004004 +- h2b_a549_mantis_2026_03_26_train/B/3/004005 +- h2b_a549_mantis_2026_03_26_train/B/3/004006 +- h2b_a549_mantis_2026_03_26_train/B/3/004007 +- h2b_a549_mantis_2026_03_26_train/B/3/004008 +- h2b_a549_mantis_2026_03_26_train/B/3/005000 +- h2b_a549_mantis_2026_03_26_train/B/3/005002 +- h2b_a549_mantis_2026_03_26_train/B/3/005003 +- h2b_a549_mantis_2026_03_26_train/B/3/005005 +- h2b_a549_mantis_2026_03_26_train/B/3/005006 +- h2b_a549_mantis_2026_03_26_train/B/3/005008 +- h2b_a549_mantis_2026_03_26_train/B/3/006000 +- h2b_a549_mantis_2026_03_26_train/B/3/006001 +- h2b_a549_mantis_2026_03_26_train/B/3/006002 +- h2b_a549_mantis_2026_03_26_train/B/3/006003 +- h2b_a549_mantis_2026_03_26_train/B/3/006004 +- h2b_a549_mantis_2026_03_26_train/B/3/006005 +- h2b_a549_mantis_2026_03_26_train/B/3/006006 +- h2b_a549_mantis_2026_03_26_train/B/3/006007 +- h2b_a549_mantis_2026_03_26_train/B/3/006008 +- h2b_a549_mantis_2026_03_26_train/B/3/007000 +- h2b_a549_mantis_2026_03_26_train/B/3/007001 +- h2b_a549_mantis_2026_03_26_train/B/3/007002 +- h2b_a549_mantis_2026_03_26_train/B/3/007003 +- h2b_a549_mantis_2026_03_26_train/B/3/007004 +- h2b_a549_mantis_2026_03_26_train/B/3/007005 +- h2b_a549_mantis_2026_03_26_train/B/3/007006 +- h2b_a549_mantis_2026_03_26_train/B/3/007007 +- h2b_a549_mantis_2026_03_26_train/B/3/007008 +- h2b_a549_mantis_2026_03_26_train/B/3/008000 +- h2b_a549_mantis_2026_03_26_train/B/3/008002 +- h2b_a549_mantis_2026_03_26_train/B/3/008003 +- h2b_a549_mantis_2026_03_26_train/B/3/008005 +- h2b_a549_mantis_2026_03_26_train/B/3/008006 +- h2b_a549_mantis_2026_03_26_train/B/3/008008 +- h2b_a549_mantis_2026_03_26_train/B/4/000000 +- h2b_a549_mantis_2026_03_26_train/B/4/000002 +- h2b_a549_mantis_2026_03_26_train/B/4/000003 +- h2b_a549_mantis_2026_03_26_train/B/4/000005 +- h2b_a549_mantis_2026_03_26_train/B/4/000006 +- h2b_a549_mantis_2026_03_26_train/B/4/000008 +- h2b_a549_mantis_2026_03_26_train/B/4/001000 +- h2b_a549_mantis_2026_03_26_train/B/4/001001 +- h2b_a549_mantis_2026_03_26_train/B/4/001002 +- h2b_a549_mantis_2026_03_26_train/B/4/001003 +- h2b_a549_mantis_2026_03_26_train/B/4/001004 +- h2b_a549_mantis_2026_03_26_train/B/4/001005 +- h2b_a549_mantis_2026_03_26_train/B/4/001006 +- h2b_a549_mantis_2026_03_26_train/B/4/001007 +- h2b_a549_mantis_2026_03_26_train/B/4/001008 +- h2b_a549_mantis_2026_03_26_train/B/4/002000 +- h2b_a549_mantis_2026_03_26_train/B/4/002001 +- h2b_a549_mantis_2026_03_26_train/B/4/002002 +- h2b_a549_mantis_2026_03_26_train/B/4/002003 +- h2b_a549_mantis_2026_03_26_train/B/4/002004 +- h2b_a549_mantis_2026_03_26_train/B/4/002005 +- h2b_a549_mantis_2026_03_26_train/B/4/002006 +- h2b_a549_mantis_2026_03_26_train/B/4/002007 +- h2b_a549_mantis_2026_03_26_train/B/4/002008 +- h2b_a549_mantis_2026_03_26_train/B/4/003000 +- h2b_a549_mantis_2026_03_26_train/B/4/003002 +- h2b_a549_mantis_2026_03_26_train/B/4/003003 +- h2b_a549_mantis_2026_03_26_train/B/4/003005 +- h2b_a549_mantis_2026_03_26_train/B/4/003006 +- h2b_a549_mantis_2026_03_26_train/B/4/003008 +- h2b_a549_mantis_2026_03_26_train/B/4/004000 +- h2b_a549_mantis_2026_03_26_train/B/4/004001 +- h2b_a549_mantis_2026_03_26_train/B/4/004002 +- h2b_a549_mantis_2026_03_26_train/B/4/004003 +- h2b_a549_mantis_2026_03_26_train/B/4/004004 +- h2b_a549_mantis_2026_03_26_train/B/4/004005 +- h2b_a549_mantis_2026_03_26_train/B/4/004006 +- h2b_a549_mantis_2026_03_26_train/B/4/004007 +- h2b_a549_mantis_2026_03_26_train/B/4/004008 +- h2b_a549_mantis_2026_03_26_train/B/4/005000 +- h2b_a549_mantis_2026_03_26_train/B/4/005002 +- h2b_a549_mantis_2026_03_26_train/B/4/005003 +- h2b_a549_mantis_2026_03_26_train/B/4/005005 +- h2b_a549_mantis_2026_03_26_train/B/4/005006 +- h2b_a549_mantis_2026_03_26_train/B/4/005008 +- h2b_a549_mantis_2026_03_26_train/B/4/006000 +- h2b_a549_mantis_2026_03_26_train/B/4/006001 +- h2b_a549_mantis_2026_03_26_train/B/4/006002 +- h2b_a549_mantis_2026_03_26_train/B/4/006003 +- h2b_a549_mantis_2026_03_26_train/B/4/006004 +- h2b_a549_mantis_2026_03_26_train/B/4/006005 +- h2b_a549_mantis_2026_03_26_train/B/4/006006 +- h2b_a549_mantis_2026_03_26_train/B/4/006007 +- h2b_a549_mantis_2026_03_26_train/B/4/006008 +- h2b_a549_mantis_2026_03_26_train/B/4/007000 +- h2b_a549_mantis_2026_03_26_train/B/4/007001 +- h2b_a549_mantis_2026_03_26_train/B/4/007002 +- h2b_a549_mantis_2026_03_26_train/B/4/007003 +- h2b_a549_mantis_2026_03_26_train/B/4/007004 +- h2b_a549_mantis_2026_03_26_train/B/4/007005 +- h2b_a549_mantis_2026_03_26_train/B/4/007006 +- h2b_a549_mantis_2026_03_26_train/B/4/007007 +- h2b_a549_mantis_2026_03_26_train/B/4/007008 +- h2b_a549_mantis_2026_03_26_train/B/4/008000 +- h2b_a549_mantis_2026_03_26_train/B/4/008002 +- h2b_a549_mantis_2026_03_26_train/B/4/008003 +- h2b_a549_mantis_2026_03_26_train/B/4/008005 +- h2b_a549_mantis_2026_03_26_train/B/4/008006 +- h2b_a549_mantis_2026_03_26_train/B/4/008008 +test_fovs: +- nucleus_hipsc_test/4/11393/1428 +- nucleus_hipsc_test/4/11479/1481 +- nucleus_hipsc_test/4/18007/1641 +- nucleus_hipsc_test/4/18102/1710 +- nucleus_hipsc_test/4/18485/1842 +- nucleus_hipsc_test/4/22901/3306 +- nucleus_hipsc_test/4/27797/2857 +- nucleus_hipsc_test/4/28759/3400 +- nucleus_hipsc_test/4/29060/3786 +- nucleus_hipsc_test/4/29140/3687 +- nucleus_hipsc_test/4/29334/3890 +- nucleus_hipsc_test/4/30293/3915 +- nucleus_hipsc_test/4/31736/15232 +- nucleus_hipsc_test/4/32024/4089 +- nucleus_hipsc_test/4/34998/4271 +- nucleus_hipsc_test/4/35284/4501 +- nucleus_hipsc_test/4/36643/4930 +- nucleus_hipsc_test/4/37601/5175 +- nucleus_hipsc_test/4/38464/5176 +- nucleus_hipsc_test/4/4556/15828 +- nucleus_hipsc_test/4/4556/16242 +- nucleus_hipsc_test/4/5910/824 +- nucleus_hipsc_test/4/6497/1014 +- nucleus_hipsc_test/4/6775/1242 +- nucleus_hipsc_test/4/8706/1138 +- nucleus_hipsc_test/4/94507/699 +- nucleus_hipsc_test/41/44212/5751 +- nucleus_hipsc_test/41/48436/5515 +- nucleus_hipsc_test/41/48536/5593 +- nucleus_hipsc_test/41/49121/5716 +- nucleus_hipsc_test/41/49121/5777 +- nucleus_hipsc_test/41/49204/5680 +- nucleus_hipsc_test/41/49888/5888 +- nucleus_hipsc_test/41/49975/5926 +- nucleus_hipsc_test/41/50548/6016 +- nucleus_hipsc_test/41/52564/5966 +- nucleus_hipsc_test/41/53048/15203 +- nucleus_hipsc_test/41/55160/6367 +- nucleus_hipsc_test/41/55348/6437 +- nucleus_hipsc_test/41/55350/6427 +- nucleus_hipsc_test/41/58326/6874 +- nucleus_hipsc_test/41/58517/6781 +- nucleus_hipsc_test/41/60728/7413 +- nucleus_hipsc_test/41/62754/7076 +- nucleus_hipsc_test/41/63524/7359 +- nucleus_hipsc_test/41/63524/7400 +- nucleus_hipsc_test/41/63713/7287 +- nucleus_hipsc_test/41/66020/7541 +- nucleus_hipsc_test/41/67168/7688 +- nucleus_hipsc_test/41/68116/7831 +- nucleus_hipsc_test/41/68598/9132 +- nucleus_hipsc_test/41/68804/8999 +- nucleus_hipsc_test/41/68884/9247 +- nucleus_hipsc_test/41/68885/9316 +- nucleus_hipsc_test/41/70240/9487 +- nucleus_hipsc_test/41/72356/7974 +- nucleus_hipsc_test/41/72629/8071 +- nucleus_hipsc_test/41/72725/8138 +- nucleus_hipsc_test/41/72727/8125 +- nucleus_hipsc_test/41/73112/8476 +- nucleus_hipsc_test/41/73304/8259 +- nucleus_hipsc_test/41/73686/8660 +- nucleus_hipsc_test/41/73686/8668 +- nucleus_hipsc_test/41/73783/8567 +- nucleus_hipsc_test/41/74264/8751 +- nucleus_hipsc_test/41/74272/8740 +- nucleus_hipsc_test/41/74356/8919 +- nucleus_hipsc_test/41/75800/8019 +- nucleus_hipsc_test/41/75808/7975 +- nucleus_hipsc_test/42/107478/10817 +- nucleus_hipsc_test/42/114584/12053 +- nucleus_hipsc_test/42/115556/15421 +- nucleus_hipsc_test/42/116598/10604 +- nucleus_hipsc_test/42/117557/11343 +- nucleus_hipsc_test/42/118901/11674 +- nucleus_hipsc_test/42/118912/11694 +- nucleus_hipsc_test/42/123916/16655 +- nucleus_hipsc_test/42/124001/16229 +- nucleus_hipsc_test/42/127171/12338 +- nucleus_hipsc_test/42/127276/23725 +- nucleus_hipsc_test/42/127939/12482 +- nucleus_hipsc_test/42/128428/12536 +- nucleus_hipsc_test/42/128523/12637 +- nucleus_hipsc_test/42/129665/12780 +- nucleus_hipsc_test/42/129855/12890 +- nucleus_hipsc_test/42/132463/13304 +- nucleus_hipsc_test/42/132834/13446 +- nucleus_hipsc_test/42/133599/13746 +- nucleus_hipsc_test/42/135439/14132 +- nucleus_hipsc_test/42/137449/14744 +- nucleus_hipsc_test/42/137455/14731 +- nucleus_hipsc_test/42/137460/14685 +- nucleus_hipsc_test/42/137582/14642 +- nucleus_hipsc_test/42/137774/14522 +- nucleus_hipsc_test/42/137820/14488 +- nucleus_hipsc_test/42/137953/15518 +- nucleus_hipsc_test/42/77924/9512 +- nucleus_hipsc_test/42/80023/9994 +- nucleus_hipsc_test/42/82708/16181 +- nucleus_hipsc_test/42/84449/15422 +- h2b_a549_mantis_2026_03_26_test/B/2/000001 +- h2b_a549_mantis_2026_03_26_test/B/2/000004 +- h2b_a549_mantis_2026_03_26_test/B/2/000007 +- h2b_a549_mantis_2026_03_26_test/B/2/003001 +- h2b_a549_mantis_2026_03_26_test/B/2/003004 +- h2b_a549_mantis_2026_03_26_test/B/2/003007 +- h2b_a549_mantis_2026_03_26_test/B/2/005001 +- h2b_a549_mantis_2026_03_26_test/B/2/005004 +- h2b_a549_mantis_2026_03_26_test/B/2/005007 +- h2b_a549_mantis_2026_03_26_test/B/2/008001 +- h2b_a549_mantis_2026_03_26_test/B/2/008004 +- h2b_a549_mantis_2026_03_26_test/B/2/008007 +- h2b_a549_mantis_2026_03_26_test/B/3/000001 +- h2b_a549_mantis_2026_03_26_test/B/3/000004 +- h2b_a549_mantis_2026_03_26_test/B/3/000007 +- h2b_a549_mantis_2026_03_26_test/B/3/003001 +- h2b_a549_mantis_2026_03_26_test/B/3/003004 +- h2b_a549_mantis_2026_03_26_test/B/3/003007 +- h2b_a549_mantis_2026_03_26_test/B/3/005001 +- h2b_a549_mantis_2026_03_26_test/B/3/005004 +- h2b_a549_mantis_2026_03_26_test/B/3/005007 +- h2b_a549_mantis_2026_03_26_test/B/3/008001 +- h2b_a549_mantis_2026_03_26_test/B/3/008004 +- h2b_a549_mantis_2026_03_26_test/B/3/008007 +- h2b_a549_mantis_2026_03_26_test/B/4/000001 +- h2b_a549_mantis_2026_03_26_test/B/4/000004 +- h2b_a549_mantis_2026_03_26_test/B/4/000007 +- h2b_a549_mantis_2026_03_26_test/B/4/003001 +- h2b_a549_mantis_2026_03_26_test/B/4/003004 +- h2b_a549_mantis_2026_03_26_test/B/4/003007 +- h2b_a549_mantis_2026_03_26_test/B/4/005001 +- h2b_a549_mantis_2026_03_26_test/B/4/005004 +- h2b_a549_mantis_2026_03_26_test/B/4/005007 +- h2b_a549_mantis_2026_03_26_test/B/4/008001 +- h2b_a549_mantis_2026_03_26_test/B/4/008004 +- h2b_a549_mantis_2026_03_26_test/B/4/008007 diff --git a/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/nucleus_joint_mock_v1.yaml b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/nucleus_joint_mock_v1.yaml new file mode 100644 index 000000000..bfeb2ac6f --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/nucleus_joint_mock_v1.yaml @@ -0,0 +1,779 @@ +name: nucleus_joint_mock_v1 +description: Joint frozen benchmark collection with condition filter 'mock' across + 2 selectors covering targets 'h2b', 'nucleus'. Channels and FOV membership captured + from the live train/test zarr stores at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-27T12:02:53.337464+00:00' + created_by: Alex Kalinin +experiments: +- name: nucleus_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Nuclei + organelle: nucleus + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: nucleus_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/cell.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: Nuclei + organelle: nucleus + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: h2b_a549_mantis_2026_03_26_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2026_03_26_A549_CAAX_H2B_DENV_ZIKV/train/H2B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: H2B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: H2B + organelle: nucleus + pixel_size_xy_um: 0.116 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: h2b_a549_mantis_2026_03_26_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2026_03_26_A549_CAAX_H2B_DENV_ZIKV/test/H2B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: H2B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: H2B + organelle: nucleus + pixel_size_xy_um: 0.116 + pixel_size_z_um: 0.174 + exclude_fovs: [] +train_fovs: +- nucleus_hipsc_train/4/10615/1304 +- nucleus_hipsc_train/4/10625/1347 +- nucleus_hipsc_train/4/10900/1427 +- nucleus_hipsc_train/4/10904/1436 +- nucleus_hipsc_train/4/11384/1404 +- nucleus_hipsc_train/4/11478/1468 +- nucleus_hipsc_train/4/11490/1466 +- nucleus_hipsc_train/4/11492/1467 +- nucleus_hipsc_train/4/11573/1414 +- nucleus_hipsc_train/4/136707/16750 +- nucleus_hipsc_train/4/136710/15363 +- nucleus_hipsc_train/4/136721/16107 +- nucleus_hipsc_train/4/136725/15834 +- nucleus_hipsc_train/4/13974/1528 +- nucleus_hipsc_train/4/14646/1871 +- nucleus_hipsc_train/4/14740/1745 +- nucleus_hipsc_train/4/14742/1791 +- nucleus_hipsc_train/4/14754/1781 +- nucleus_hipsc_train/4/1493/268 +- nucleus_hipsc_train/4/1508/255 +- nucleus_hipsc_train/4/16278/2186 +- nucleus_hipsc_train/4/16376/2374 +- nucleus_hipsc_train/4/16468/2321 +- nucleus_hipsc_train/4/16469/2337 +- nucleus_hipsc_train/4/16469/2339 +- nucleus_hipsc_train/4/16469/2345 +- nucleus_hipsc_train/4/16471/2265 +- nucleus_hipsc_train/4/16472/2312 +- nucleus_hipsc_train/4/16951/2459 +- nucleus_hipsc_train/4/16951/2480 +- nucleus_hipsc_train/4/16952/2494 +- nucleus_hipsc_train/4/17333/2710 +- nucleus_hipsc_train/4/17348/16148 +- nucleus_hipsc_train/4/17525/2811 +- nucleus_hipsc_train/4/17526/2752 +- nucleus_hipsc_train/4/17536/2773 +- nucleus_hipsc_train/4/18020/1618 +- nucleus_hipsc_train/4/18020/1625 +- nucleus_hipsc_train/4/18020/1638 +- nucleus_hipsc_train/4/18487/1811 +- nucleus_hipsc_train/4/19351/1905 +- nucleus_hipsc_train/4/19543/2105 +- nucleus_hipsc_train/4/19554/2020 +- nucleus_hipsc_train/4/19556/2089 +- nucleus_hipsc_train/4/20416/2223 +- nucleus_hipsc_train/4/20596/2406 +- nucleus_hipsc_train/4/20597/2395 +- nucleus_hipsc_train/4/20597/2401 +- nucleus_hipsc_train/4/20599/2373 +- nucleus_hipsc_train/4/21077/2254 +- nucleus_hipsc_train/4/21089/2293 +- nucleus_hipsc_train/4/21556/2491 +- nucleus_hipsc_train/4/21557/2483 +- nucleus_hipsc_train/4/21557/2527 +- nucleus_hipsc_train/4/21653/2547 +- nucleus_hipsc_train/4/21860/15671 +- nucleus_hipsc_train/4/21940/2736 +- nucleus_hipsc_train/4/21943/2717 +- nucleus_hipsc_train/4/21953/2739 +- nucleus_hipsc_train/4/22133/2826 +- nucleus_hipsc_train/4/22136/2827 +- nucleus_hipsc_train/4/22339/3095 +- nucleus_hipsc_train/4/22340/3097 +- nucleus_hipsc_train/4/22612/2915 +- nucleus_hipsc_train/4/22614/2923 +- nucleus_hipsc_train/4/22615/2978 +- nucleus_hipsc_train/4/22624/2909 +- nucleus_hipsc_train/4/22709/3070 +- nucleus_hipsc_train/4/22712/3090 +- nucleus_hipsc_train/4/22913/3301 +- nucleus_hipsc_train/4/22914/3289 +- nucleus_hipsc_train/4/23380/3237 +- nucleus_hipsc_train/4/23392/3212 +- nucleus_hipsc_train/4/23395/3223 +- nucleus_hipsc_train/4/23574/3492 +- nucleus_hipsc_train/4/23764/3409 +- nucleus_hipsc_train/4/24152/3567 +- nucleus_hipsc_train/4/24724/3661 +- nucleus_hipsc_train/4/24727/3659 +- nucleus_hipsc_train/4/24928/3585 +- nucleus_hipsc_train/4/25784/3851 +- nucleus_hipsc_train/4/27800/2883 +- nucleus_hipsc_train/4/27896/2943 +- nucleus_hipsc_train/4/27992/3020 +- nucleus_hipsc_train/4/28084/3214 +- nucleus_hipsc_train/4/28084/3270 +- nucleus_hipsc_train/4/28087/3266 +- nucleus_hipsc_train/4/28756/3381 +- nucleus_hipsc_train/4/28759/3393 +- nucleus_hipsc_train/4/29045/3764 +- nucleus_hipsc_train/4/29060/3753 +- nucleus_hipsc_train/4/29143/3667 +- nucleus_hipsc_train/4/29155/3710 +- nucleus_hipsc_train/4/2932/230 +- nucleus_hipsc_train/4/29333/3908 +- nucleus_hipsc_train/4/2945/173 +- nucleus_hipsc_train/4/30292/14379 +- nucleus_hipsc_train/4/30293/3905 +- nucleus_hipsc_train/4/30308/3869 +- nucleus_hipsc_train/4/30388/16862 +- nucleus_hipsc_train/4/30389/15342 +- nucleus_hipsc_train/4/30392/16741 +- nucleus_hipsc_train/4/31732/17059 +- nucleus_hipsc_train/4/31744/16779 +- nucleus_hipsc_train/4/31841/3962 +- nucleus_hipsc_train/4/31939/3975 +- nucleus_hipsc_train/4/32024/4077 +- nucleus_hipsc_train/4/32033/4111 +- nucleus_hipsc_train/4/32033/4121 +- nucleus_hipsc_train/4/32035/4099 +- nucleus_hipsc_train/4/33077/4379 +- nucleus_hipsc_train/4/33572/4229 +- nucleus_hipsc_train/4/33942/15337 +- nucleus_hipsc_train/4/33942/16205 +- nucleus_hipsc_train/4/33943/17061 +- nucleus_hipsc_train/4/33953/16561 +- nucleus_hipsc_train/4/33955/16023 +- nucleus_hipsc_train/4/34038/4363 +- nucleus_hipsc_train/4/34808/4417 +- nucleus_hipsc_train/4/35000/4274 +- nucleus_hipsc_train/4/35284/4472 +- nucleus_hipsc_train/4/35287/4460 +- nucleus_hipsc_train/4/35479/4551 +- nucleus_hipsc_train/4/35489/4583 +- nucleus_hipsc_train/4/36449/15327 +- nucleus_hipsc_train/4/36544/4909 +- nucleus_hipsc_train/4/36544/4931 +- nucleus_hipsc_train/4/36628/4907 +- nucleus_hipsc_train/4/36836/4996 +- nucleus_hipsc_train/4/37591/5133 +- nucleus_hipsc_train/4/37603/5147 +- nucleus_hipsc_train/4/37972/5388 +- nucleus_hipsc_train/4/37988/5373 +- nucleus_hipsc_train/4/40084/5359 +- nucleus_hipsc_train/4/40086/5362 +- nucleus_hipsc_train/4/40376/4584 +- nucleus_hipsc_train/4/40385/4614 +- nucleus_hipsc_train/4/40386/4613 +- nucleus_hipsc_train/4/40387/4586 +- nucleus_hipsc_train/4/40483/4619 +- nucleus_hipsc_train/4/40483/4621 +- nucleus_hipsc_train/4/40960/4654 +- nucleus_hipsc_train/4/41044/4851 +- nucleus_hipsc_train/4/41047/4885 +- nucleus_hipsc_train/4/41237/4861 +- nucleus_hipsc_train/4/41249/4835 +- nucleus_hipsc_train/4/41912/5074 +- nucleus_hipsc_train/4/5143/954 +- nucleus_hipsc_train/4/5236/869 +- nucleus_hipsc_train/4/5238/875 +- nucleus_hipsc_train/4/6485/1018 +- nucleus_hipsc_train/4/6486/992 +- nucleus_hipsc_train/4/6497/1003 +- nucleus_hipsc_train/4/6775/1203 +- nucleus_hipsc_train/4/6775/1226 +- nucleus_hipsc_train/4/6775/1236 +- nucleus_hipsc_train/4/7156/1124 +- nucleus_hipsc_train/4/7349/1355 +- nucleus_hipsc_train/4/7650/1278 +- nucleus_hipsc_train/4/8214/878 +- nucleus_hipsc_train/4/8214/879 +- nucleus_hipsc_train/4/8228/898 +- nucleus_hipsc_train/4/8695/1215 +- nucleus_hipsc_train/4/88267/15294 +- nucleus_hipsc_train/4/89048/356 +- nucleus_hipsc_train/4/8982/1171 +- nucleus_hipsc_train/4/90088/415 +- nucleus_hipsc_train/4/90858/15658 +- nucleus_hipsc_train/4/90858/16534 +- nucleus_hipsc_train/4/91144/102 +- nucleus_hipsc_train/4/91924/458 +- nucleus_hipsc_train/4/93448/596 +- nucleus_hipsc_train/4/94312/684 +- nucleus_hipsc_train/4/95752/811 +- nucleus_hipsc_train/4/95753/737 +- nucleus_hipsc_train/4/95753/872 +- nucleus_hipsc_train/41/43638/5246 +- nucleus_hipsc_train/41/43639/5265 +- nucleus_hipsc_train/41/43732/16519 +- nucleus_hipsc_train/41/45556/5706 +- nucleus_hipsc_train/41/45556/5734 +- nucleus_hipsc_train/41/45559/5714 +- nucleus_hipsc_train/41/48436/5507 +- nucleus_hipsc_train/41/48534/5575 +- nucleus_hipsc_train/41/48535/5623 +- nucleus_hipsc_train/41/48548/5574 +- nucleus_hipsc_train/41/48548/5589 +- nucleus_hipsc_train/41/49204/5661 +- nucleus_hipsc_train/41/49220/5671 +- nucleus_hipsc_train/41/49698/5819 +- nucleus_hipsc_train/41/49972/5933 +- nucleus_hipsc_train/41/49973/5960 +- nucleus_hipsc_train/41/50263/6077 +- nucleus_hipsc_train/41/50263/6082 +- nucleus_hipsc_train/41/50356/15510 +- nucleus_hipsc_train/41/50356/15578 +- nucleus_hipsc_train/41/50359/15457 +- nucleus_hipsc_train/41/50548/6024 +- nucleus_hipsc_train/41/50551/6022 +- nucleus_hipsc_train/41/53044/15243 +- nucleus_hipsc_train/41/53046/16965 +- nucleus_hipsc_train/41/53428/6238 +- nucleus_hipsc_train/41/53524/15636 +- nucleus_hipsc_train/41/53538/15395 +- nucleus_hipsc_train/41/53731/15920 +- nucleus_hipsc_train/41/55156/6355 +- nucleus_hipsc_train/41/55156/6358 +- nucleus_hipsc_train/41/55158/6324 +- nucleus_hipsc_train/41/55158/6353 +- nucleus_hipsc_train/41/55253/6499 +- nucleus_hipsc_train/41/55256/6482 +- nucleus_hipsc_train/41/55351/6419 +- nucleus_hipsc_train/41/55363/6362 +- nucleus_hipsc_train/41/55925/6584 +- nucleus_hipsc_train/41/56406/6643 +- nucleus_hipsc_train/41/56416/6614 +- nucleus_hipsc_train/41/56418/6626 +- nucleus_hipsc_train/41/56419/6630 +- nucleus_hipsc_train/41/56596/6678 +- nucleus_hipsc_train/41/56896/7720 +- nucleus_hipsc_train/41/57364/6456 +- nucleus_hipsc_train/41/57365/6428 +- nucleus_hipsc_train/41/57367/6430 +- nucleus_hipsc_train/41/57464/6544 +- nucleus_hipsc_train/41/57472/6556 +- nucleus_hipsc_train/41/57472/6565 +- nucleus_hipsc_train/41/58134/6821 +- nucleus_hipsc_train/41/58326/6840 +- nucleus_hipsc_train/41/58420/6971 +- nucleus_hipsc_train/41/58423/6963 +- nucleus_hipsc_train/41/58518/6786 +- nucleus_hipsc_train/41/59285/7118 +- nucleus_hipsc_train/41/59285/7124 +- nucleus_hipsc_train/41/59298/7175 +- nucleus_hipsc_train/41/59380/7015 +- nucleus_hipsc_train/41/59479/7188 +- nucleus_hipsc_train/41/59479/7200 +- nucleus_hipsc_train/41/59480/7179 +- nucleus_hipsc_train/41/60548/7475 +- nucleus_hipsc_train/41/60632/7345 +- nucleus_hipsc_train/41/60726/7399 +- nucleus_hipsc_train/41/60737/7332 +- nucleus_hipsc_train/41/60738/7414 +- nucleus_hipsc_train/41/62740/7068 +- nucleus_hipsc_train/41/62932/6916 +- nucleus_hipsc_train/41/63508/7389 +- nucleus_hipsc_train/41/63523/7383 +- nucleus_hipsc_train/41/63608/7462 +- nucleus_hipsc_train/41/63608/7464 +- nucleus_hipsc_train/41/63620/7451 +- nucleus_hipsc_train/41/63701/7283 +- nucleus_hipsc_train/41/63713/7256 +- nucleus_hipsc_train/41/66292/7775 +- nucleus_hipsc_train/41/66292/7782 +- nucleus_hipsc_train/41/66292/7796 +- nucleus_hipsc_train/41/66296/7788 +- nucleus_hipsc_train/41/67157/7690 +- nucleus_hipsc_train/41/67168/7678 +- nucleus_hipsc_train/41/68131/7834 +- nucleus_hipsc_train/41/68503/9206 +- nucleus_hipsc_train/41/68504/9176 +- nucleus_hipsc_train/41/68504/9197 +- nucleus_hipsc_train/41/68512/9188 +- nucleus_hipsc_train/41/68512/9207 +- nucleus_hipsc_train/41/68512/9212 +- nucleus_hipsc_train/41/68708/9065 +- nucleus_hipsc_train/41/68788/9030 +- nucleus_hipsc_train/41/68800/9019 +- nucleus_hipsc_train/41/69472/9285 +- nucleus_hipsc_train/41/69473/9279 +- nucleus_hipsc_train/41/69474/9306 +- nucleus_hipsc_train/41/70052/15689 +- nucleus_hipsc_train/41/70231/9525 +- nucleus_hipsc_train/41/70232/9551 +- nucleus_hipsc_train/41/72244/8037 +- nucleus_hipsc_train/41/72244/8074 +- nucleus_hipsc_train/41/72256/8049 +- nucleus_hipsc_train/41/72260/8085 +- nucleus_hipsc_train/41/72342/7994 +- nucleus_hipsc_train/41/72356/7962 +- nucleus_hipsc_train/41/72628/8109 +- nucleus_hipsc_train/41/72629/8086 +- nucleus_hipsc_train/41/72630/8119 +- nucleus_hipsc_train/41/72631/8095 +- nucleus_hipsc_train/41/72725/8151 +- nucleus_hipsc_train/41/72726/8128 +- nucleus_hipsc_train/41/72834/8288 +- nucleus_hipsc_train/41/73300/8255 +- nucleus_hipsc_train/41/73396/8265 +- nucleus_hipsc_train/41/73397/8271 +- nucleus_hipsc_train/41/73398/8307 +- nucleus_hipsc_train/41/73495/8186 +- nucleus_hipsc_train/41/73507/8203 +- nucleus_hipsc_train/41/73685/8634 +- nucleus_hipsc_train/41/73687/8628 +- nucleus_hipsc_train/41/73700/8663 +- nucleus_hipsc_train/41/73782/8525 +- nucleus_hipsc_train/41/73782/8576 +- nucleus_hipsc_train/41/73783/8530 +- nucleus_hipsc_train/41/73784/8543 +- nucleus_hipsc_train/41/73879/15995 +- nucleus_hipsc_train/41/73975/15832 +- nucleus_hipsc_train/41/74165/8821 +- nucleus_hipsc_train/41/74168/8793 +- nucleus_hipsc_train/41/74260/8727 +- nucleus_hipsc_train/41/74273/8721 +- nucleus_hipsc_train/41/74371/8941 +- nucleus_hipsc_train/41/74371/8978 +- nucleus_hipsc_train/41/75042/7915 +- nucleus_hipsc_train/41/75124/16978 +- nucleus_hipsc_train/41/75125/16693 +- nucleus_hipsc_train/41/75512/7872 +- nucleus_hipsc_train/41/75796/7941 +- nucleus_hipsc_train/41/75799/7953 +- nucleus_hipsc_train/41/76000/8244 +- nucleus_hipsc_train/41/77250/8868 +- nucleus_hipsc_train/41/77333/9094 +- nucleus_hipsc_train/42/106420/10373 +- nucleus_hipsc_train/42/106421/10380 +- nucleus_hipsc_train/42/106422/10368 +- nucleus_hipsc_train/42/106516/10272 +- nucleus_hipsc_train/42/106518/10239 +- nucleus_hipsc_train/42/106520/10262 +- nucleus_hipsc_train/42/106915/10747 +- nucleus_hipsc_train/42/106996/10652 +- nucleus_hipsc_train/42/106998/10641 +- nucleus_hipsc_train/42/107480/10815 +- nucleus_hipsc_train/42/107480/10822 +- nucleus_hipsc_train/42/107572/12022 +- nucleus_hipsc_train/42/107574/11982 +- nucleus_hipsc_train/42/107574/12039 +- nucleus_hipsc_train/42/107682/11895 +- nucleus_hipsc_train/42/107682/11898 +- nucleus_hipsc_train/42/107684/11928 +- nucleus_hipsc_train/42/107956/11969 +- nucleus_hipsc_train/42/107956/11981 +- nucleus_hipsc_train/42/107958/11911 +- nucleus_hipsc_train/42/107959/12029 +- nucleus_hipsc_train/42/107972/11941 +- nucleus_hipsc_train/42/108148/15673 +- nucleus_hipsc_train/42/108149/12190 +- nucleus_hipsc_train/42/108246/11135 +- nucleus_hipsc_train/42/108248/16355 +- nucleus_hipsc_train/42/108824/15581 +- nucleus_hipsc_train/42/108833/15155 +- nucleus_hipsc_train/42/110548/10130 +- nucleus_hipsc_train/42/110552/10154 +- nucleus_hipsc_train/42/110552/10175 +- nucleus_hipsc_train/42/110645/10108 +- nucleus_hipsc_train/42/110646/10124 +- nucleus_hipsc_train/42/110660/10091 +- nucleus_hipsc_train/42/110947/10199 +- nucleus_hipsc_train/42/111125/10242 +- nucleus_hipsc_train/42/111413/10485 +- nucleus_hipsc_train/42/111415/10486 +- nucleus_hipsc_train/42/111426/10473 +- nucleus_hipsc_train/42/111892/10724 +- nucleus_hipsc_train/42/112084/15061 +- nucleus_hipsc_train/42/112085/16293 +- nucleus_hipsc_train/42/112280/15454 +- nucleus_hipsc_train/42/112565/10904 +- nucleus_hipsc_train/42/112758/16064 +- nucleus_hipsc_train/42/112772/14973 +- nucleus_hipsc_train/42/113432/11852 +- nucleus_hipsc_train/42/113634/10939 +- nucleus_hipsc_train/42/113921/11053 +- nucleus_hipsc_train/42/114209/10977 +- nucleus_hipsc_train/42/114212/10981 +- nucleus_hipsc_train/42/114787/11121 +- nucleus_hipsc_train/42/114788/11097 +- nucleus_hipsc_train/42/114965/11232 +- nucleus_hipsc_train/42/114965/11269 +- nucleus_hipsc_train/42/114979/11222 +- nucleus_hipsc_train/42/115160/12126 +- nucleus_hipsc_train/42/115169/16617 +- nucleus_hipsc_train/42/115349/11410 +- nucleus_hipsc_train/42/115541/15346 +- nucleus_hipsc_train/42/115542/16879 +- nucleus_hipsc_train/42/115552/15185 +- nucleus_hipsc_train/42/115554/15716 +- nucleus_hipsc_train/42/115555/16425 +- nucleus_hipsc_train/42/115556/15703 +- nucleus_hipsc_train/42/115831/11479 +- nucleus_hipsc_train/42/116034/11497 +- nucleus_hipsc_train/42/116309/11595 +- nucleus_hipsc_train/42/116324/11616 +- nucleus_hipsc_train/42/116608/10515 +- nucleus_hipsc_train/42/116608/10614 +- nucleus_hipsc_train/42/116887/10440 +- nucleus_hipsc_train/42/116897/10412 +- nucleus_hipsc_train/42/116900/10422 +- nucleus_hipsc_train/42/117173/10673 +- nucleus_hipsc_train/42/117186/10657 +- nucleus_hipsc_train/42/117557/11347 +- nucleus_hipsc_train/42/117559/11367 +- nucleus_hipsc_train/42/117572/11385 +- nucleus_hipsc_train/42/117847/11299 +- nucleus_hipsc_train/42/118420/11731 +- nucleus_hipsc_train/42/118423/11658 +- nucleus_hipsc_train/42/118712/11569 +- nucleus_hipsc_train/42/118806/11804 +- nucleus_hipsc_train/42/118808/11800 +- nucleus_hipsc_train/42/121791/16666 +- nucleus_hipsc_train/42/121793/15852 +- nucleus_hipsc_train/42/121806/15946 +- nucleus_hipsc_train/42/123328/15550 +- nucleus_hipsc_train/42/123328/17092 +- nucleus_hipsc_train/42/123714/16851 +- nucleus_hipsc_train/42/123903/15431 +- nucleus_hipsc_train/42/124002/16132 +- nucleus_hipsc_train/42/124014/16885 +- nucleus_hipsc_train/42/124205/15565 +- nucleus_hipsc_train/42/124287/15382 +- nucleus_hipsc_train/42/124290/15483 +- nucleus_hipsc_train/42/124291/15731 +- nucleus_hipsc_train/42/124299/16712 +- nucleus_hipsc_train/42/124301/15843 +- nucleus_hipsc_train/42/127171/12333 +- nucleus_hipsc_train/42/127647/12252 +- nucleus_hipsc_train/42/127648/12223 +- nucleus_hipsc_train/42/127649/12208 +- nucleus_hipsc_train/42/127650/12238 +- nucleus_hipsc_train/42/127650/12256 +- nucleus_hipsc_train/42/127651/12217 +- nucleus_hipsc_train/42/127651/12239 +- nucleus_hipsc_train/42/127852/12320 +- nucleus_hipsc_train/42/127935/12457 +- nucleus_hipsc_train/42/127947/12485 +- nucleus_hipsc_train/42/128416/12512 +- nucleus_hipsc_train/42/128514/12657 +- nucleus_hipsc_train/42/128514/12667 +- nucleus_hipsc_train/42/128525/12654 +- nucleus_hipsc_train/42/128715/12598 +- nucleus_hipsc_train/42/128718/12626 +- nucleus_hipsc_train/42/128719/12625 +- nucleus_hipsc_train/42/129473/12830 +- nucleus_hipsc_train/42/129473/12852 +- nucleus_hipsc_train/42/129571/12811 +- nucleus_hipsc_train/42/129583/12802 +- nucleus_hipsc_train/42/129774/12715 +- nucleus_hipsc_train/42/129855/12931 +- nucleus_hipsc_train/42/130155/13043 +- nucleus_hipsc_train/42/130527/12960 +- nucleus_hipsc_train/42/130625/16186 +- nucleus_hipsc_train/42/130707/13231 +- nucleus_hipsc_train/42/130722/17097 +- nucleus_hipsc_train/42/132173/13409 +- nucleus_hipsc_train/42/132175/13365 +- nucleus_hipsc_train/42/132653/13278 +- nucleus_hipsc_train/42/132831/13415 +- nucleus_hipsc_train/42/132844/13432 +- nucleus_hipsc_train/42/132845/13448 +- nucleus_hipsc_train/42/132929/13513 +- nucleus_hipsc_train/42/133133/13640 +- nucleus_hipsc_train/42/133323/13465 +- nucleus_hipsc_train/42/133324/13457 +- nucleus_hipsc_train/42/133325/13497 +- nucleus_hipsc_train/42/133503/13577 +- nucleus_hipsc_train/42/133504/13572 +- nucleus_hipsc_train/42/133602/13711 +- nucleus_hipsc_train/42/133711/13788 +- nucleus_hipsc_train/42/134272/13918 +- nucleus_hipsc_train/42/134286/13916 +- nucleus_hipsc_train/42/134656/13884 +- nucleus_hipsc_train/42/135272/14059 +- nucleus_hipsc_train/42/135440/14128 +- nucleus_hipsc_train/42/135525/14245 +- nucleus_hipsc_train/42/135614/14178 +- nucleus_hipsc_train/42/137434/14771 +- nucleus_hipsc_train/42/137464/14708 +- nucleus_hipsc_train/42/137767/14413 +- nucleus_hipsc_train/42/137772/14516 +- nucleus_hipsc_train/42/137956/15501 +- nucleus_hipsc_train/42/137956/16613 +- nucleus_hipsc_train/42/137956/17196 +- nucleus_hipsc_train/42/137956/17224 +- nucleus_hipsc_train/42/138024/15890 +- nucleus_hipsc_train/42/138028/16174 +- nucleus_hipsc_train/42/138032/15577 +- nucleus_hipsc_train/42/138261/16083 +- nucleus_hipsc_train/42/77912/9479 +- nucleus_hipsc_train/42/77912/9520 +- nucleus_hipsc_train/42/77923/9543 +- nucleus_hipsc_train/42/78389/9675 +- nucleus_hipsc_train/42/78391/9672 +- nucleus_hipsc_train/42/78487/9750 +- nucleus_hipsc_train/42/78487/9758 +- nucleus_hipsc_train/42/78691/9802 +- nucleus_hipsc_train/42/79541/9897 +- nucleus_hipsc_train/42/79552/9894 +- nucleus_hipsc_train/42/79554/9874 +- nucleus_hipsc_train/42/79828/9972 +- nucleus_hipsc_train/42/79831/9969 +- nucleus_hipsc_train/42/79832/9978 +- nucleus_hipsc_train/42/79841/9963 +- nucleus_hipsc_train/42/80023/15006 +- nucleus_hipsc_train/42/80033/15189 +- nucleus_hipsc_train/42/80035/9980 +- nucleus_hipsc_train/42/80224/9960 +- nucleus_hipsc_train/42/83392/9630 +- h2b_a549_mantis_2026_03_26_train/B/2/000002 +- h2b_a549_mantis_2026_03_26_train/B/2/000003 +- h2b_a549_mantis_2026_03_26_train/B/2/000005 +- h2b_a549_mantis_2026_03_26_train/B/2/000006 +- h2b_a549_mantis_2026_03_26_train/B/2/000008 +- h2b_a549_mantis_2026_03_26_train/B/2/001000 +- h2b_a549_mantis_2026_03_26_train/B/2/001001 +- h2b_a549_mantis_2026_03_26_train/B/2/001002 +- h2b_a549_mantis_2026_03_26_train/B/2/001003 +- h2b_a549_mantis_2026_03_26_train/B/2/001004 +- h2b_a549_mantis_2026_03_26_train/B/2/001005 +- h2b_a549_mantis_2026_03_26_train/B/2/001006 +- h2b_a549_mantis_2026_03_26_train/B/2/001007 +- h2b_a549_mantis_2026_03_26_train/B/2/001008 +- h2b_a549_mantis_2026_03_26_train/B/2/002000 +- h2b_a549_mantis_2026_03_26_train/B/2/002001 +- h2b_a549_mantis_2026_03_26_train/B/2/002002 +- h2b_a549_mantis_2026_03_26_train/B/2/002003 +- h2b_a549_mantis_2026_03_26_train/B/2/002004 +- h2b_a549_mantis_2026_03_26_train/B/2/002005 +- h2b_a549_mantis_2026_03_26_train/B/2/002006 +- h2b_a549_mantis_2026_03_26_train/B/2/002007 +- h2b_a549_mantis_2026_03_26_train/B/2/002008 +- h2b_a549_mantis_2026_03_26_train/B/2/003000 +- h2b_a549_mantis_2026_03_26_train/B/2/003002 +- h2b_a549_mantis_2026_03_26_train/B/2/003003 +- h2b_a549_mantis_2026_03_26_train/B/2/003005 +- h2b_a549_mantis_2026_03_26_train/B/2/003006 +- h2b_a549_mantis_2026_03_26_train/B/2/003008 +- h2b_a549_mantis_2026_03_26_train/B/2/004000 +- h2b_a549_mantis_2026_03_26_train/B/2/004001 +- h2b_a549_mantis_2026_03_26_train/B/2/004002 +- h2b_a549_mantis_2026_03_26_train/B/2/004003 +- h2b_a549_mantis_2026_03_26_train/B/2/004004 +- h2b_a549_mantis_2026_03_26_train/B/2/004005 +- h2b_a549_mantis_2026_03_26_train/B/2/004006 +- h2b_a549_mantis_2026_03_26_train/B/2/004007 +- h2b_a549_mantis_2026_03_26_train/B/2/004008 +- h2b_a549_mantis_2026_03_26_train/B/2/005000 +- h2b_a549_mantis_2026_03_26_train/B/2/005002 +- h2b_a549_mantis_2026_03_26_train/B/2/005003 +- h2b_a549_mantis_2026_03_26_train/B/2/005005 +- h2b_a549_mantis_2026_03_26_train/B/2/005006 +- h2b_a549_mantis_2026_03_26_train/B/2/005008 +- h2b_a549_mantis_2026_03_26_train/B/2/006000 +- h2b_a549_mantis_2026_03_26_train/B/2/006001 +- h2b_a549_mantis_2026_03_26_train/B/2/006002 +- h2b_a549_mantis_2026_03_26_train/B/2/006003 +- h2b_a549_mantis_2026_03_26_train/B/2/006004 +- h2b_a549_mantis_2026_03_26_train/B/2/006005 +- h2b_a549_mantis_2026_03_26_train/B/2/006006 +- h2b_a549_mantis_2026_03_26_train/B/2/006007 +- h2b_a549_mantis_2026_03_26_train/B/2/006008 +- h2b_a549_mantis_2026_03_26_train/B/2/007000 +- h2b_a549_mantis_2026_03_26_train/B/2/007001 +- h2b_a549_mantis_2026_03_26_train/B/2/007002 +- h2b_a549_mantis_2026_03_26_train/B/2/007003 +- h2b_a549_mantis_2026_03_26_train/B/2/007004 +- h2b_a549_mantis_2026_03_26_train/B/2/007005 +- h2b_a549_mantis_2026_03_26_train/B/2/007006 +- h2b_a549_mantis_2026_03_26_train/B/2/007007 +- h2b_a549_mantis_2026_03_26_train/B/2/007008 +- h2b_a549_mantis_2026_03_26_train/B/2/008000 +- h2b_a549_mantis_2026_03_26_train/B/2/008002 +- h2b_a549_mantis_2026_03_26_train/B/2/008003 +- h2b_a549_mantis_2026_03_26_train/B/2/008005 +- h2b_a549_mantis_2026_03_26_train/B/2/008006 +- h2b_a549_mantis_2026_03_26_train/B/2/008008 +test_fovs: +- nucleus_hipsc_test/4/11393/1428 +- nucleus_hipsc_test/4/11479/1481 +- nucleus_hipsc_test/4/18007/1641 +- nucleus_hipsc_test/4/18102/1710 +- nucleus_hipsc_test/4/18485/1842 +- nucleus_hipsc_test/4/22901/3306 +- nucleus_hipsc_test/4/27797/2857 +- nucleus_hipsc_test/4/28759/3400 +- nucleus_hipsc_test/4/29060/3786 +- nucleus_hipsc_test/4/29140/3687 +- nucleus_hipsc_test/4/29334/3890 +- nucleus_hipsc_test/4/30293/3915 +- nucleus_hipsc_test/4/31736/15232 +- nucleus_hipsc_test/4/32024/4089 +- nucleus_hipsc_test/4/34998/4271 +- nucleus_hipsc_test/4/35284/4501 +- nucleus_hipsc_test/4/36643/4930 +- nucleus_hipsc_test/4/37601/5175 +- nucleus_hipsc_test/4/38464/5176 +- nucleus_hipsc_test/4/4556/15828 +- nucleus_hipsc_test/4/4556/16242 +- nucleus_hipsc_test/4/5910/824 +- nucleus_hipsc_test/4/6497/1014 +- nucleus_hipsc_test/4/6775/1242 +- nucleus_hipsc_test/4/8706/1138 +- nucleus_hipsc_test/4/94507/699 +- nucleus_hipsc_test/41/44212/5751 +- nucleus_hipsc_test/41/48436/5515 +- nucleus_hipsc_test/41/48536/5593 +- nucleus_hipsc_test/41/49121/5716 +- nucleus_hipsc_test/41/49121/5777 +- nucleus_hipsc_test/41/49204/5680 +- nucleus_hipsc_test/41/49888/5888 +- nucleus_hipsc_test/41/49975/5926 +- nucleus_hipsc_test/41/50548/6016 +- nucleus_hipsc_test/41/52564/5966 +- nucleus_hipsc_test/41/53048/15203 +- nucleus_hipsc_test/41/55160/6367 +- nucleus_hipsc_test/41/55348/6437 +- nucleus_hipsc_test/41/55350/6427 +- nucleus_hipsc_test/41/58326/6874 +- nucleus_hipsc_test/41/58517/6781 +- nucleus_hipsc_test/41/60728/7413 +- nucleus_hipsc_test/41/62754/7076 +- nucleus_hipsc_test/41/63524/7359 +- nucleus_hipsc_test/41/63524/7400 +- nucleus_hipsc_test/41/63713/7287 +- nucleus_hipsc_test/41/66020/7541 +- nucleus_hipsc_test/41/67168/7688 +- nucleus_hipsc_test/41/68116/7831 +- nucleus_hipsc_test/41/68598/9132 +- nucleus_hipsc_test/41/68804/8999 +- nucleus_hipsc_test/41/68884/9247 +- nucleus_hipsc_test/41/68885/9316 +- nucleus_hipsc_test/41/70240/9487 +- nucleus_hipsc_test/41/72356/7974 +- nucleus_hipsc_test/41/72629/8071 +- nucleus_hipsc_test/41/72725/8138 +- nucleus_hipsc_test/41/72727/8125 +- nucleus_hipsc_test/41/73112/8476 +- nucleus_hipsc_test/41/73304/8259 +- nucleus_hipsc_test/41/73686/8660 +- nucleus_hipsc_test/41/73686/8668 +- nucleus_hipsc_test/41/73783/8567 +- nucleus_hipsc_test/41/74264/8751 +- nucleus_hipsc_test/41/74272/8740 +- nucleus_hipsc_test/41/74356/8919 +- nucleus_hipsc_test/41/75800/8019 +- nucleus_hipsc_test/41/75808/7975 +- nucleus_hipsc_test/42/107478/10817 +- nucleus_hipsc_test/42/114584/12053 +- nucleus_hipsc_test/42/115556/15421 +- nucleus_hipsc_test/42/116598/10604 +- nucleus_hipsc_test/42/117557/11343 +- nucleus_hipsc_test/42/118901/11674 +- nucleus_hipsc_test/42/118912/11694 +- nucleus_hipsc_test/42/123916/16655 +- nucleus_hipsc_test/42/124001/16229 +- nucleus_hipsc_test/42/127171/12338 +- nucleus_hipsc_test/42/127276/23725 +- nucleus_hipsc_test/42/127939/12482 +- nucleus_hipsc_test/42/128428/12536 +- nucleus_hipsc_test/42/128523/12637 +- nucleus_hipsc_test/42/129665/12780 +- nucleus_hipsc_test/42/129855/12890 +- nucleus_hipsc_test/42/132463/13304 +- nucleus_hipsc_test/42/132834/13446 +- nucleus_hipsc_test/42/133599/13746 +- nucleus_hipsc_test/42/135439/14132 +- nucleus_hipsc_test/42/137449/14744 +- nucleus_hipsc_test/42/137455/14731 +- nucleus_hipsc_test/42/137460/14685 +- nucleus_hipsc_test/42/137582/14642 +- nucleus_hipsc_test/42/137774/14522 +- nucleus_hipsc_test/42/137820/14488 +- nucleus_hipsc_test/42/137953/15518 +- nucleus_hipsc_test/42/77924/9512 +- nucleus_hipsc_test/42/80023/9994 +- nucleus_hipsc_test/42/82708/16181 +- nucleus_hipsc_test/42/84449/15422 +- h2b_a549_mantis_2026_03_26_test/B/2/000001 +- h2b_a549_mantis_2026_03_26_test/B/2/000004 +- h2b_a549_mantis_2026_03_26_test/B/2/000007 +- h2b_a549_mantis_2026_03_26_test/B/2/003001 +- h2b_a549_mantis_2026_03_26_test/B/2/003004 +- h2b_a549_mantis_2026_03_26_test/B/2/003007 +- h2b_a549_mantis_2026_03_26_test/B/2/005001 +- h2b_a549_mantis_2026_03_26_test/B/2/005004 +- h2b_a549_mantis_2026_03_26_test/B/2/005007 +- h2b_a549_mantis_2026_03_26_test/B/2/008001 +- h2b_a549_mantis_2026_03_26_test/B/2/008004 +- h2b_a549_mantis_2026_03_26_test/B/2/008007 diff --git a/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/sec61b_ipsc_v1.yaml b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/sec61b_ipsc_v1.yaml new file mode 100644 index 000000000..6ac12c675 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/sec61b_ipsc_v1.yaml @@ -0,0 +1,587 @@ +name: sec61b_ipsc_v1 +description: Frozen benchmark collection for 'aics-hipsc' target 'sec61b'. Channels + and FOV membership captured from the live train/test zarr stores at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-21T00:00:00Z' + created_by: Alex Kalinin +experiments: +- name: sec61b_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: SEC61B + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: sec61b_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/SEC61B.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: SEC61B + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +train_fovs: +- sec61b_hipsc_train/4/38452/5161 +- sec61b_hipsc_train/4/38452/5165 +- sec61b_hipsc_train/4/38452/5177 +- sec61b_hipsc_train/4/38452/5184 +- sec61b_hipsc_train/4/38452/5194 +- sec61b_hipsc_train/4/38452/5198 +- sec61b_hipsc_train/4/38464/5157 +- sec61b_hipsc_train/4/38464/5159 +- sec61b_hipsc_train/4/38464/5176 +- sec61b_hipsc_train/4/38464/5179 +- sec61b_hipsc_train/4/38464/5181 +- sec61b_hipsc_train/4/38464/5186 +- sec61b_hipsc_train/4/38464/5190 +- sec61b_hipsc_train/4/38464/5199 +- sec61b_hipsc_train/4/38464/5202 +- sec61b_hipsc_train/4/38465/5164 +- sec61b_hipsc_train/4/38465/5171 +- sec61b_hipsc_train/4/38465/5191 +- sec61b_hipsc_train/4/38465/5195 +- sec61b_hipsc_train/4/38465/5197 +- sec61b_hipsc_train/4/38466/5155 +- sec61b_hipsc_train/4/38466/5168 +- sec61b_hipsc_train/4/38466/5188 +- sec61b_hipsc_train/4/38466/5192 +- sec61b_hipsc_train/4/38466/5193 +- sec61b_hipsc_train/4/38466/5196 +- sec61b_hipsc_train/4/39124/5221 +- sec61b_hipsc_train/4/39124/5223 +- sec61b_hipsc_train/4/39124/5247 +- sec61b_hipsc_train/4/39124/5258 +- sec61b_hipsc_train/4/39124/5280 +- sec61b_hipsc_train/4/39125/5264 +- sec61b_hipsc_train/4/39126/5229 +- sec61b_hipsc_train/4/39127/5283 +- sec61b_hipsc_train/4/39128/5219 +- sec61b_hipsc_train/4/39128/5260 +- sec61b_hipsc_train/4/39128/5272 +- sec61b_hipsc_train/4/39136/5225 +- sec61b_hipsc_train/4/39136/5234 +- sec61b_hipsc_train/4/39136/5236 +- sec61b_hipsc_train/4/39136/5239 +- sec61b_hipsc_train/4/39137/5243 +- sec61b_hipsc_train/4/39137/5266 +- sec61b_hipsc_train/4/39137/5274 +- sec61b_hipsc_train/4/39137/5277 +- sec61b_hipsc_train/4/39138/5256 +- sec61b_hipsc_train/4/39138/5262 +- sec61b_hipsc_train/4/39138/5270 +- sec61b_hipsc_train/4/39139/5220 +- sec61b_hipsc_train/4/39139/5244 +- sec61b_hipsc_train/4/39139/5249 +- sec61b_hipsc_train/4/39139/5250 +- sec61b_hipsc_train/4/39140/5222 +- sec61b_hipsc_train/4/39140/5232 +- sec61b_hipsc_train/4/39140/5240 +- sec61b_hipsc_train/4/39222/5288 +- sec61b_hipsc_train/4/39222/5291 +- sec61b_hipsc_train/4/39222/5298 +- sec61b_hipsc_train/4/39222/5303 +- sec61b_hipsc_train/4/39222/5324 +- sec61b_hipsc_train/4/39224/5294 +- sec61b_hipsc_train/4/39224/5302 +- sec61b_hipsc_train/4/39224/5307 +- sec61b_hipsc_train/4/39224/5321 +- sec61b_hipsc_train/4/39224/5326 +- sec61b_hipsc_train/4/39224/5332 +- sec61b_hipsc_train/4/39232/5278 +- sec61b_hipsc_train/4/39232/5318 +- sec61b_hipsc_train/4/39232/5323 +- sec61b_hipsc_train/4/39232/5330 +- sec61b_hipsc_train/4/39233/5299 +- sec61b_hipsc_train/4/39233/5309 +- sec61b_hipsc_train/4/39233/5322 +- sec61b_hipsc_train/4/39236/5316 +- sec61b_hipsc_train/4/39236/5317 +- sec61b_hipsc_train/4/40084/5359 +- sec61b_hipsc_train/4/40084/5380 +- sec61b_hipsc_train/4/40084/5407 +- sec61b_hipsc_train/4/40084/5429 +- sec61b_hipsc_train/4/40085/5371 +- sec61b_hipsc_train/4/40085/5383 +- sec61b_hipsc_train/4/40085/5389 +- sec61b_hipsc_train/4/40086/5401 +- sec61b_hipsc_train/4/40087/5377 +- sec61b_hipsc_train/4/40087/5405 +- sec61b_hipsc_train/4/40087/5428 +- sec61b_hipsc_train/4/40088/5365 +- sec61b_hipsc_train/4/40088/5368 +- sec61b_hipsc_train/4/40088/5392 +- sec61b_hipsc_train/4/40088/5398 +- sec61b_hipsc_train/4/40088/5403 +- sec61b_hipsc_train/4/40088/5417 +- sec61b_hipsc_train/4/40088/5422 +- sec61b_hipsc_train/4/40088/5424 +- sec61b_hipsc_train/4/40088/5430 +- sec61b_hipsc_train/4/40098/5386 +- sec61b_hipsc_train/4/40098/5409 +- sec61b_hipsc_train/4/40098/5427 +- sec61b_hipsc_train/4/40180/5447 +- sec61b_hipsc_train/4/40180/5461 +- sec61b_hipsc_train/4/40180/5475 +- sec61b_hipsc_train/4/40180/5497 +- sec61b_hipsc_train/4/40181/5435 +- sec61b_hipsc_train/4/40181/5441 +- sec61b_hipsc_train/4/40181/5443 +- sec61b_hipsc_train/4/40181/5481 +- sec61b_hipsc_train/4/40182/5432 +- sec61b_hipsc_train/4/40182/5433 +- sec61b_hipsc_train/4/40182/5455 +- sec61b_hipsc_train/4/40182/5498 +- sec61b_hipsc_train/4/40184/5439 +- sec61b_hipsc_train/4/40184/5457 +- sec61b_hipsc_train/4/40194/5459 +- sec61b_hipsc_train/4/40194/5463 +- sec61b_hipsc_train/4/40195/5436 +- sec61b_hipsc_train/4/40195/5483 +- sec61b_hipsc_train/4/40195/5489 +- sec61b_hipsc_train/4/40195/5491 +- sec61b_hipsc_train/4/40375/4566 +- sec61b_hipsc_train/4/40375/4599 +- sec61b_hipsc_train/4/40375/4608 +- sec61b_hipsc_train/4/40376/4563 +- sec61b_hipsc_train/4/40376/4584 +- sec61b_hipsc_train/4/40376/4605 +- sec61b_hipsc_train/4/40376/4607 +- sec61b_hipsc_train/4/40376/4609 +- sec61b_hipsc_train/4/40385/4557 +- sec61b_hipsc_train/4/40385/4559 +- sec61b_hipsc_train/4/40385/4578 +- sec61b_hipsc_train/4/40385/4593 +- sec61b_hipsc_train/4/40385/4614 +- sec61b_hipsc_train/4/40386/4580 +- sec61b_hipsc_train/4/40386/4611 +- sec61b_hipsc_train/4/40386/4613 +- sec61b_hipsc_train/4/40387/4561 +- sec61b_hipsc_train/4/40387/4582 +- sec61b_hipsc_train/4/40387/4586 +- sec61b_hipsc_train/4/40387/4595 +- sec61b_hipsc_train/4/40387/4597 +- sec61b_hipsc_train/4/40388/4574 +- sec61b_hipsc_train/4/40388/4588 +- sec61b_hipsc_train/4/40468/4620 +- sec61b_hipsc_train/4/40468/4650 +- sec61b_hipsc_train/4/40468/4653 +- sec61b_hipsc_train/4/40468/4655 +- sec61b_hipsc_train/4/40469/4641 +- sec61b_hipsc_train/4/40469/4666 +- sec61b_hipsc_train/4/40469/4673 +- sec61b_hipsc_train/4/40470/4615 +- sec61b_hipsc_train/4/40470/4616 +- sec61b_hipsc_train/4/40470/4671 +- sec61b_hipsc_train/4/40470/4675 +- sec61b_hipsc_train/4/40470/4677 +- sec61b_hipsc_train/4/40471/4632 +- sec61b_hipsc_train/4/40471/4657 +- sec61b_hipsc_train/4/40471/4664 +- sec61b_hipsc_train/4/40481/4622 +- sec61b_hipsc_train/4/40481/4633 +- sec61b_hipsc_train/4/40481/4647 +- sec61b_hipsc_train/4/40481/4668 +- sec61b_hipsc_train/4/40483/4617 +- sec61b_hipsc_train/4/40483/4619 +- sec61b_hipsc_train/4/40483/4629 +- sec61b_hipsc_train/4/40484/4618 +- sec61b_hipsc_train/4/40484/4626 +- sec61b_hipsc_train/4/40484/4663 +- sec61b_hipsc_train/4/40960/4625 +- sec61b_hipsc_train/4/40960/4628 +- sec61b_hipsc_train/4/40960/4640 +- sec61b_hipsc_train/4/40960/4654 +- sec61b_hipsc_train/4/40960/4656 +- sec61b_hipsc_train/4/40960/4674 +- sec61b_hipsc_train/4/40960/4678 +- sec61b_hipsc_train/4/40961/4635 +- sec61b_hipsc_train/4/40961/4669 +- sec61b_hipsc_train/4/40962/4676 +- sec61b_hipsc_train/4/40964/4623 +- sec61b_hipsc_train/4/40964/4631 +- sec61b_hipsc_train/4/40964/4649 +- sec61b_hipsc_train/4/40964/4660 +- sec61b_hipsc_train/4/40964/4667 +- sec61b_hipsc_train/4/40964/4672 +- sec61b_hipsc_train/4/41044/4843 +- sec61b_hipsc_train/4/41044/4847 +- sec61b_hipsc_train/4/41044/4851 +- sec61b_hipsc_train/4/41044/4876 +- sec61b_hipsc_train/4/41044/4895 +- sec61b_hipsc_train/4/41045/4853 +- sec61b_hipsc_train/4/41045/4873 +- sec61b_hipsc_train/4/41045/4889 +- sec61b_hipsc_train/4/41045/4893 +- sec61b_hipsc_train/4/41046/4900 +- sec61b_hipsc_train/4/41047/4845 +- sec61b_hipsc_train/4/41047/4882 +- sec61b_hipsc_train/4/41047/4883 +- sec61b_hipsc_train/4/41047/4902 +- sec61b_hipsc_train/4/41057/4860 +- sec61b_hipsc_train/4/41057/4864 +- sec61b_hipsc_train/4/41057/4875 +- sec61b_hipsc_train/4/41057/4877 +- sec61b_hipsc_train/4/41057/4896 +- sec61b_hipsc_train/4/41058/4855 +- sec61b_hipsc_train/4/41058/4879 +- sec61b_hipsc_train/4/41058/4897 +- sec61b_hipsc_train/4/41058/4899 +- sec61b_hipsc_train/4/41059/4841 +- sec61b_hipsc_train/4/41059/4867 +- sec61b_hipsc_train/4/41059/4884 +- sec61b_hipsc_train/4/41059/4888 +- sec61b_hipsc_train/4/41059/4890 +- sec61b_hipsc_train/4/41059/4892 +- sec61b_hipsc_train/4/41060/4859 +- sec61b_hipsc_train/4/41060/4862 +- sec61b_hipsc_train/4/41060/4878 +- sec61b_hipsc_train/4/41060/4880 +- sec61b_hipsc_train/4/41060/4881 +- sec61b_hipsc_train/4/41060/4894 +- sec61b_hipsc_train/4/41060/4898 +- sec61b_hipsc_train/4/41237/4813 +- sec61b_hipsc_train/4/41237/4826 +- sec61b_hipsc_train/4/41237/4840 +- sec61b_hipsc_train/4/41237/4842 +- sec61b_hipsc_train/4/41237/4861 +- sec61b_hipsc_train/4/41237/4865 +- sec61b_hipsc_train/4/41237/4870 +- sec61b_hipsc_train/4/41238/4815 +- sec61b_hipsc_train/4/41238/4816 +- sec61b_hipsc_train/4/41238/4819 +- sec61b_hipsc_train/4/41238/4827 +- sec61b_hipsc_train/4/41238/4839 +- sec61b_hipsc_train/4/41238/4844 +- sec61b_hipsc_train/4/41238/4874 +- sec61b_hipsc_train/4/41239/4817 +- sec61b_hipsc_train/4/41239/4824 +- sec61b_hipsc_train/4/41239/4830 +- sec61b_hipsc_train/4/41239/4833 +- sec61b_hipsc_train/4/41239/4836 +- sec61b_hipsc_train/4/41239/4838 +- sec61b_hipsc_train/4/41240/4814 +- sec61b_hipsc_train/4/41240/4820 +- sec61b_hipsc_train/4/41240/4821 +- sec61b_hipsc_train/4/41240/4825 +- sec61b_hipsc_train/4/41240/4831 +- sec61b_hipsc_train/4/41240/4852 +- sec61b_hipsc_train/4/41240/4858 +- sec61b_hipsc_train/4/41240/4866 +- sec61b_hipsc_train/4/41249/4835 +- sec61b_hipsc_train/4/41249/4837 +- sec61b_hipsc_train/4/41249/4868 +- sec61b_hipsc_train/4/41335/4810 +- sec61b_hipsc_train/4/41347/4804 +- sec61b_hipsc_train/4/41347/4808 +- sec61b_hipsc_train/4/41347/4812 +- sec61b_hipsc_train/4/41348/4805 +- sec61b_hipsc_train/4/41348/4806 +- sec61b_hipsc_train/4/41348/4807 +- sec61b_hipsc_train/4/41348/4811 +- sec61b_hipsc_train/4/41428/4714 +- sec61b_hipsc_train/4/41428/4723 +- sec61b_hipsc_train/4/41428/4737 +- sec61b_hipsc_train/4/41428/4739 +- sec61b_hipsc_train/4/41430/4722 +- sec61b_hipsc_train/4/41430/4732 +- sec61b_hipsc_train/4/41430/4733 +- sec61b_hipsc_train/4/41430/4741 +- sec61b_hipsc_train/4/41430/4742 +- sec61b_hipsc_train/4/41432/4716 +- sec61b_hipsc_train/4/41432/4719 +- sec61b_hipsc_train/4/41432/4720 +- sec61b_hipsc_train/4/41432/4724 +- sec61b_hipsc_train/4/41432/4726 +- sec61b_hipsc_train/4/41432/4740 +- sec61b_hipsc_train/4/41441/4721 +- sec61b_hipsc_train/4/41441/4727 +- sec61b_hipsc_train/4/41441/4728 +- sec61b_hipsc_train/4/41441/4731 +- sec61b_hipsc_train/4/41441/4734 +- sec61b_hipsc_train/4/41441/4735 +- sec61b_hipsc_train/4/41908/5019 +- sec61b_hipsc_train/4/41908/5021 +- sec61b_hipsc_train/4/41908/5043 +- sec61b_hipsc_train/4/41908/5098 +- sec61b_hipsc_train/4/41908/5099 +- sec61b_hipsc_train/4/41909/5025 +- sec61b_hipsc_train/4/41909/5035 +- sec61b_hipsc_train/4/41909/5046 +- sec61b_hipsc_train/4/41909/5082 +- sec61b_hipsc_train/4/41909/5084 +- sec61b_hipsc_train/4/41909/5092 +- sec61b_hipsc_train/4/41909/5096 +- sec61b_hipsc_train/4/41910/5017 +- sec61b_hipsc_train/4/41910/5023 +- sec61b_hipsc_train/4/41910/5033 +- sec61b_hipsc_train/4/41910/5093 +- sec61b_hipsc_train/4/41911/5015 +- sec61b_hipsc_train/4/41911/5029 +- sec61b_hipsc_train/4/41911/5055 +- sec61b_hipsc_train/4/41911/5064 +- sec61b_hipsc_train/4/41911/5079 +- sec61b_hipsc_train/4/41911/5080 +- sec61b_hipsc_train/4/41911/5086 +- sec61b_hipsc_train/4/41911/5094 +- sec61b_hipsc_train/4/41912/5039 +- sec61b_hipsc_train/4/41912/5041 +- sec61b_hipsc_train/4/41912/5052 +- sec61b_hipsc_train/4/41912/5074 +- sec61b_hipsc_train/4/41912/5095 +- sec61b_hipsc_train/4/42197/5020 +- sec61b_hipsc_train/4/42197/5026 +- sec61b_hipsc_train/4/42197/5030 +- sec61b_hipsc_train/4/42197/5036 +- sec61b_hipsc_train/4/42197/5075 +- sec61b_hipsc_train/4/42199/5032 +- sec61b_hipsc_train/4/42199/5045 +- sec61b_hipsc_train/4/42199/5063 +- sec61b_hipsc_train/4/42199/5066 +- sec61b_hipsc_train/4/42199/5069 +- sec61b_hipsc_train/4/42200/5016 +- sec61b_hipsc_train/4/42200/5028 +- sec61b_hipsc_train/4/42200/5038 +- sec61b_hipsc_train/4/42211/5018 +- sec61b_hipsc_train/4/42211/5024 +- sec61b_hipsc_train/4/42211/5051 +- sec61b_hipsc_train/4/42211/5053 +- sec61b_hipsc_train/4/42211/5057 +- sec61b_hipsc_train/42/136118/15182 +- sec61b_hipsc_train/42/136118/15269 +- sec61b_hipsc_train/42/136118/16846 +- sec61b_hipsc_train/42/136119/14226 +- sec61b_hipsc_train/42/136119/14227 +- sec61b_hipsc_train/42/136119/15430 +- sec61b_hipsc_train/42/136119/15573 +- sec61b_hipsc_train/42/136120/15452 +- sec61b_hipsc_train/42/136120/15958 +- sec61b_hipsc_train/42/136120/16873 +- sec61b_hipsc_train/42/136121/15700 +- sec61b_hipsc_train/42/136121/16618 +- sec61b_hipsc_train/42/136121/17149 +- sec61b_hipsc_train/42/136122/16832 +- sec61b_hipsc_train/42/136122/16883 +- sec61b_hipsc_train/42/136122/16987 +- sec61b_hipsc_train/42/136122/17182 +- sec61b_hipsc_train/42/136124/15667 +- sec61b_hipsc_train/42/136124/15715 +- sec61b_hipsc_train/42/136126/15932 +- sec61b_hipsc_train/42/136126/16322 +- sec61b_hipsc_train/42/138024/15523 +- sec61b_hipsc_train/42/138024/15890 +- sec61b_hipsc_train/42/138024/16225 +- sec61b_hipsc_train/42/138024/16287 +- sec61b_hipsc_train/42/138024/16991 +- sec61b_hipsc_train/42/138025/15979 +- sec61b_hipsc_train/42/138025/16227 +- sec61b_hipsc_train/42/138025/16897 +- sec61b_hipsc_train/42/138025/17204 +- sec61b_hipsc_train/42/138025/17241 +- sec61b_hipsc_train/42/138026/15744 +- sec61b_hipsc_train/42/138026/16036 +- sec61b_hipsc_train/42/138026/16240 +- sec61b_hipsc_train/42/138026/17153 +- sec61b_hipsc_train/42/138026/17201 +- sec61b_hipsc_train/42/138026/17206 +- sec61b_hipsc_train/42/138026/17257 +- sec61b_hipsc_train/42/138027/17190 +- sec61b_hipsc_train/42/138027/17231 +- sec61b_hipsc_train/42/138027/17262 +- sec61b_hipsc_train/42/138028/15886 +- sec61b_hipsc_train/42/138028/16174 +- sec61b_hipsc_train/42/138028/16396 +- sec61b_hipsc_train/42/138028/17142 +- sec61b_hipsc_train/42/138028/17192 +- sec61b_hipsc_train/42/138028/17244 +- sec61b_hipsc_train/42/138030/15632 +- sec61b_hipsc_train/42/138030/15792 +- sec61b_hipsc_train/42/138030/15894 +- sec61b_hipsc_train/42/138032/15614 +- sec61b_hipsc_train/42/138032/15851 +- sec61b_hipsc_train/42/138032/16266 +- sec61b_hipsc_train/42/138032/16928 +- sec61b_hipsc_train/42/138032/17205 +- sec61b_hipsc_train/42/138032/17209 +- sec61b_hipsc_train/42/138033/17171 +- sec61b_hipsc_train/42/138033/17255 +- sec61b_hipsc_train/42/138037/15612 +- sec61b_hipsc_train/42/138037/16696 +- sec61b_hipsc_train/42/138037/17203 +- sec61b_hipsc_train/42/138037/17223 +- sec61b_hipsc_train/42/138044/15587 +- sec61b_hipsc_train/42/138044/16757 +- sec61b_hipsc_train/42/138044/17236 +- sec61b_hipsc_train/42/138045/15540 +- sec61b_hipsc_train/42/138045/15558 +- sec61b_hipsc_train/42/138045/15684 +- sec61b_hipsc_train/42/138045/15786 +- sec61b_hipsc_train/42/138045/16126 +- sec61b_hipsc_train/42/138045/16159 +- sec61b_hipsc_train/42/138045/16598 +- sec61b_hipsc_train/42/138045/17164 +- sec61b_hipsc_train/42/138045/17234 +- sec61b_hipsc_train/42/138045/17242 +- sec61b_hipsc_train/42/138045/17256 +- sec61b_hipsc_train/42/138247/17207 +- sec61b_hipsc_train/42/138249/16356 +- sec61b_hipsc_train/42/138249/17200 +- sec61b_hipsc_train/42/138251/15688 +- sec61b_hipsc_train/42/138251/15760 +- sec61b_hipsc_train/42/138251/15918 +- sec61b_hipsc_train/42/138251/16722 +- sec61b_hipsc_train/42/138251/16982 +- sec61b_hipsc_train/42/138251/17191 +- sec61b_hipsc_train/42/138253/15957 +- sec61b_hipsc_train/42/138253/16263 +- sec61b_hipsc_train/42/138253/16587 +- sec61b_hipsc_train/42/138253/16799 +- sec61b_hipsc_train/42/138253/16955 +- sec61b_hipsc_train/42/138257/16247 +- sec61b_hipsc_train/42/138257/16292 +- sec61b_hipsc_train/42/138257/16306 +- sec61b_hipsc_train/42/138257/16480 +- sec61b_hipsc_train/42/138257/17221 +- sec61b_hipsc_train/42/138261/15887 +- sec61b_hipsc_train/42/138261/16083 +- sec61b_hipsc_train/42/138261/16860 +test_fovs: +- sec61b_hipsc_test/4/38452/5187 +- sec61b_hipsc_test/4/38452/5201 +- sec61b_hipsc_test/4/38452/5203 +- sec61b_hipsc_test/4/38464/5173 +- sec61b_hipsc_test/4/38465/5189 +- sec61b_hipsc_test/4/38466/5200 +- sec61b_hipsc_test/4/39124/5286 +- sec61b_hipsc_test/4/39125/5224 +- sec61b_hipsc_test/4/39126/5289 +- sec61b_hipsc_test/4/39128/5230 +- sec61b_hipsc_test/4/39128/5254 +- sec61b_hipsc_test/4/39137/5252 +- sec61b_hipsc_test/4/39138/5268 +- sec61b_hipsc_test/4/39140/5293 +- sec61b_hipsc_test/4/39222/5281 +- sec61b_hipsc_test/4/39222/5311 +- sec61b_hipsc_test/4/39232/5329 +- sec61b_hipsc_test/4/39233/5304 +- sec61b_hipsc_test/4/39233/5313 +- sec61b_hipsc_test/4/39233/5327 +- sec61b_hipsc_test/4/39236/5305 +- sec61b_hipsc_test/4/40084/5357 +- sec61b_hipsc_test/4/40084/5415 +- sec61b_hipsc_test/4/40085/5421 +- sec61b_hipsc_test/4/40086/5362 +- sec61b_hipsc_test/4/40181/5434 +- sec61b_hipsc_test/4/40181/5451 +- sec61b_hipsc_test/4/40181/5453 +- sec61b_hipsc_test/4/40195/5479 +- sec61b_hipsc_test/4/40196/5471 +- sec61b_hipsc_test/4/40375/4612 +- sec61b_hipsc_test/4/40376/4568 +- sec61b_hipsc_test/4/40376/4601 +- sec61b_hipsc_test/4/40376/4604 +- sec61b_hipsc_test/4/40385/4565 +- sec61b_hipsc_test/4/40385/4572 +- sec61b_hipsc_test/4/40385/4576 +- sec61b_hipsc_test/4/40385/4610 +- sec61b_hipsc_test/4/40386/4603 +- sec61b_hipsc_test/4/40386/4606 +- sec61b_hipsc_test/4/40387/4570 +- sec61b_hipsc_test/4/40388/4591 +- sec61b_hipsc_test/4/40468/4624 +- sec61b_hipsc_test/4/40471/4659 +- sec61b_hipsc_test/4/40471/4661 +- sec61b_hipsc_test/4/40471/4679 +- sec61b_hipsc_test/4/40481/4627 +- sec61b_hipsc_test/4/40483/4621 +- sec61b_hipsc_test/4/40483/4637 +- sec61b_hipsc_test/4/40483/4644 +- sec61b_hipsc_test/4/40960/4630 +- sec61b_hipsc_test/4/40961/4665 +- sec61b_hipsc_test/4/40964/4643 +- sec61b_hipsc_test/4/41044/4869 +- sec61b_hipsc_test/4/41044/4891 +- sec61b_hipsc_test/4/41046/4849 +- sec61b_hipsc_test/4/41047/4885 +- sec61b_hipsc_test/4/41057/4887 +- sec61b_hipsc_test/4/41059/4886 +- sec61b_hipsc_test/4/41060/4901 +- sec61b_hipsc_test/4/41238/4828 +- sec61b_hipsc_test/4/41239/4823 +- sec61b_hipsc_test/4/41239/4832 +- sec61b_hipsc_test/4/41240/4818 +- sec61b_hipsc_test/4/41240/4834 +- sec61b_hipsc_test/4/41335/4803 +- sec61b_hipsc_test/4/41348/4809 +- sec61b_hipsc_test/4/41428/4713 +- sec61b_hipsc_test/4/41428/4718 +- sec61b_hipsc_test/4/41428/4743 +- sec61b_hipsc_test/4/41430/4744 +- sec61b_hipsc_test/4/41432/4729 +- sec61b_hipsc_test/4/41441/4725 +- sec61b_hipsc_test/4/41908/5037 +- sec61b_hipsc_test/4/41908/5061 +- sec61b_hipsc_test/4/41909/5071 +- sec61b_hipsc_test/4/41910/5031 +- sec61b_hipsc_test/4/41910/5058 +- sec61b_hipsc_test/4/41910/5088 +- sec61b_hipsc_test/4/41911/5027 +- sec61b_hipsc_test/4/42199/5048 +- sec61b_hipsc_test/4/42211/5034 +- sec61b_hipsc_test/42/136118/14223 +- sec61b_hipsc_test/42/136118/14225 +- sec61b_hipsc_test/42/136118/16503 +- sec61b_hipsc_test/42/136119/16504 +- sec61b_hipsc_test/42/136120/14221 +- sec61b_hipsc_test/42/136120/14224 +- sec61b_hipsc_test/42/136120/14228 +- sec61b_hipsc_test/42/136120/15747 +- sec61b_hipsc_test/42/136124/16127 +- sec61b_hipsc_test/42/138024/17222 +- sec61b_hipsc_test/42/138026/17232 +- sec61b_hipsc_test/42/138028/15839 +- sec61b_hipsc_test/42/138028/17202 +- sec61b_hipsc_test/42/138032/15577 +- sec61b_hipsc_test/42/138044/15777 +- sec61b_hipsc_test/42/138045/16692 +- sec61b_hipsc_test/42/138251/17249 +- sec61b_hipsc_test/42/138253/15966 diff --git a/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/sec61b_joint_all_v1.yaml b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/sec61b_joint_all_v1.yaml new file mode 100644 index 000000000..20264e00e --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/sec61b_joint_all_v1.yaml @@ -0,0 +1,806 @@ +name: sec61b_joint_all_v1 +description: Joint frozen benchmark collection for target 'sec61b' across 5 source + datasets. Channels and FOV membership captured from the live train/test zarr stores + at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-24T19:29:05.345825+00:00' + created_by: Alex Kalinin +experiments: +- name: sec61b_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: SEC61B + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: sec61b_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/SEC61B.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: SEC61B + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: sec61b_a549_mantis_2024_10_31_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_10_31_A549_SEC61_ZIKV_DENV/train/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2024_10_31_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_10_31_A549_SEC61_ZIKV_DENV/test/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2024_11_07_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_07_A549_SEC61_DENV/train/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2024_11_07_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_07_A549_SEC61_DENV/test/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2025_07_24_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV/train/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2025_07_24_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV/test/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2025_08_26_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_08_26_A549_SEC61_TOMM20_ZIKV/train/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2025_08_26_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_08_26_A549_SEC61_TOMM20_ZIKV/test/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +train_fovs: +- sec61b_hipsc_train/4/38452/5161 +- sec61b_hipsc_train/4/38452/5165 +- sec61b_hipsc_train/4/38452/5177 +- sec61b_hipsc_train/4/38452/5184 +- sec61b_hipsc_train/4/38452/5194 +- sec61b_hipsc_train/4/38452/5198 +- sec61b_hipsc_train/4/38464/5157 +- sec61b_hipsc_train/4/38464/5159 +- sec61b_hipsc_train/4/38464/5176 +- sec61b_hipsc_train/4/38464/5179 +- sec61b_hipsc_train/4/38464/5181 +- sec61b_hipsc_train/4/38464/5186 +- sec61b_hipsc_train/4/38464/5190 +- sec61b_hipsc_train/4/38464/5199 +- sec61b_hipsc_train/4/38464/5202 +- sec61b_hipsc_train/4/38465/5164 +- sec61b_hipsc_train/4/38465/5171 +- sec61b_hipsc_train/4/38465/5191 +- sec61b_hipsc_train/4/38465/5195 +- sec61b_hipsc_train/4/38465/5197 +- sec61b_hipsc_train/4/38466/5155 +- sec61b_hipsc_train/4/38466/5168 +- sec61b_hipsc_train/4/38466/5188 +- sec61b_hipsc_train/4/38466/5192 +- sec61b_hipsc_train/4/38466/5193 +- sec61b_hipsc_train/4/38466/5196 +- sec61b_hipsc_train/4/39124/5221 +- sec61b_hipsc_train/4/39124/5223 +- sec61b_hipsc_train/4/39124/5247 +- sec61b_hipsc_train/4/39124/5258 +- sec61b_hipsc_train/4/39124/5280 +- sec61b_hipsc_train/4/39125/5264 +- sec61b_hipsc_train/4/39126/5229 +- sec61b_hipsc_train/4/39127/5283 +- sec61b_hipsc_train/4/39128/5219 +- sec61b_hipsc_train/4/39128/5260 +- sec61b_hipsc_train/4/39128/5272 +- sec61b_hipsc_train/4/39136/5225 +- sec61b_hipsc_train/4/39136/5234 +- sec61b_hipsc_train/4/39136/5236 +- sec61b_hipsc_train/4/39136/5239 +- sec61b_hipsc_train/4/39137/5243 +- sec61b_hipsc_train/4/39137/5266 +- sec61b_hipsc_train/4/39137/5274 +- sec61b_hipsc_train/4/39137/5277 +- sec61b_hipsc_train/4/39138/5256 +- sec61b_hipsc_train/4/39138/5262 +- sec61b_hipsc_train/4/39138/5270 +- sec61b_hipsc_train/4/39139/5220 +- sec61b_hipsc_train/4/39139/5244 +- sec61b_hipsc_train/4/39139/5249 +- sec61b_hipsc_train/4/39139/5250 +- sec61b_hipsc_train/4/39140/5222 +- sec61b_hipsc_train/4/39140/5232 +- sec61b_hipsc_train/4/39140/5240 +- sec61b_hipsc_train/4/39222/5288 +- sec61b_hipsc_train/4/39222/5291 +- sec61b_hipsc_train/4/39222/5298 +- sec61b_hipsc_train/4/39222/5303 +- sec61b_hipsc_train/4/39222/5324 +- sec61b_hipsc_train/4/39224/5294 +- sec61b_hipsc_train/4/39224/5302 +- sec61b_hipsc_train/4/39224/5307 +- sec61b_hipsc_train/4/39224/5321 +- sec61b_hipsc_train/4/39224/5326 +- sec61b_hipsc_train/4/39224/5332 +- sec61b_hipsc_train/4/39232/5278 +- sec61b_hipsc_train/4/39232/5318 +- sec61b_hipsc_train/4/39232/5323 +- sec61b_hipsc_train/4/39232/5330 +- sec61b_hipsc_train/4/39233/5299 +- sec61b_hipsc_train/4/39233/5309 +- sec61b_hipsc_train/4/39233/5322 +- sec61b_hipsc_train/4/39236/5316 +- sec61b_hipsc_train/4/39236/5317 +- sec61b_hipsc_train/4/40084/5359 +- sec61b_hipsc_train/4/40084/5380 +- sec61b_hipsc_train/4/40084/5407 +- sec61b_hipsc_train/4/40084/5429 +- sec61b_hipsc_train/4/40085/5371 +- sec61b_hipsc_train/4/40085/5383 +- sec61b_hipsc_train/4/40085/5389 +- sec61b_hipsc_train/4/40086/5401 +- sec61b_hipsc_train/4/40087/5377 +- sec61b_hipsc_train/4/40087/5405 +- sec61b_hipsc_train/4/40087/5428 +- sec61b_hipsc_train/4/40088/5365 +- sec61b_hipsc_train/4/40088/5368 +- sec61b_hipsc_train/4/40088/5392 +- sec61b_hipsc_train/4/40088/5398 +- sec61b_hipsc_train/4/40088/5403 +- sec61b_hipsc_train/4/40088/5417 +- sec61b_hipsc_train/4/40088/5422 +- sec61b_hipsc_train/4/40088/5424 +- sec61b_hipsc_train/4/40088/5430 +- sec61b_hipsc_train/4/40098/5386 +- sec61b_hipsc_train/4/40098/5409 +- sec61b_hipsc_train/4/40098/5427 +- sec61b_hipsc_train/4/40180/5447 +- sec61b_hipsc_train/4/40180/5461 +- sec61b_hipsc_train/4/40180/5475 +- sec61b_hipsc_train/4/40180/5497 +- sec61b_hipsc_train/4/40181/5435 +- sec61b_hipsc_train/4/40181/5441 +- sec61b_hipsc_train/4/40181/5443 +- sec61b_hipsc_train/4/40181/5481 +- sec61b_hipsc_train/4/40182/5432 +- sec61b_hipsc_train/4/40182/5433 +- sec61b_hipsc_train/4/40182/5455 +- sec61b_hipsc_train/4/40182/5498 +- sec61b_hipsc_train/4/40184/5439 +- sec61b_hipsc_train/4/40184/5457 +- sec61b_hipsc_train/4/40194/5459 +- sec61b_hipsc_train/4/40194/5463 +- sec61b_hipsc_train/4/40195/5436 +- sec61b_hipsc_train/4/40195/5483 +- sec61b_hipsc_train/4/40195/5489 +- sec61b_hipsc_train/4/40195/5491 +- sec61b_hipsc_train/4/40375/4566 +- sec61b_hipsc_train/4/40375/4599 +- sec61b_hipsc_train/4/40375/4608 +- sec61b_hipsc_train/4/40376/4563 +- sec61b_hipsc_train/4/40376/4584 +- sec61b_hipsc_train/4/40376/4605 +- sec61b_hipsc_train/4/40376/4607 +- sec61b_hipsc_train/4/40376/4609 +- sec61b_hipsc_train/4/40385/4557 +- sec61b_hipsc_train/4/40385/4559 +- sec61b_hipsc_train/4/40385/4578 +- sec61b_hipsc_train/4/40385/4593 +- sec61b_hipsc_train/4/40385/4614 +- sec61b_hipsc_train/4/40386/4580 +- sec61b_hipsc_train/4/40386/4611 +- sec61b_hipsc_train/4/40386/4613 +- sec61b_hipsc_train/4/40387/4561 +- sec61b_hipsc_train/4/40387/4582 +- sec61b_hipsc_train/4/40387/4586 +- sec61b_hipsc_train/4/40387/4595 +- sec61b_hipsc_train/4/40387/4597 +- sec61b_hipsc_train/4/40388/4574 +- sec61b_hipsc_train/4/40388/4588 +- sec61b_hipsc_train/4/40468/4620 +- sec61b_hipsc_train/4/40468/4650 +- sec61b_hipsc_train/4/40468/4653 +- sec61b_hipsc_train/4/40468/4655 +- sec61b_hipsc_train/4/40469/4641 +- sec61b_hipsc_train/4/40469/4666 +- sec61b_hipsc_train/4/40469/4673 +- sec61b_hipsc_train/4/40470/4615 +- sec61b_hipsc_train/4/40470/4616 +- sec61b_hipsc_train/4/40470/4671 +- sec61b_hipsc_train/4/40470/4675 +- sec61b_hipsc_train/4/40470/4677 +- sec61b_hipsc_train/4/40471/4632 +- sec61b_hipsc_train/4/40471/4657 +- sec61b_hipsc_train/4/40471/4664 +- sec61b_hipsc_train/4/40481/4622 +- sec61b_hipsc_train/4/40481/4633 +- sec61b_hipsc_train/4/40481/4647 +- sec61b_hipsc_train/4/40481/4668 +- sec61b_hipsc_train/4/40483/4617 +- sec61b_hipsc_train/4/40483/4619 +- sec61b_hipsc_train/4/40483/4629 +- sec61b_hipsc_train/4/40484/4618 +- sec61b_hipsc_train/4/40484/4626 +- sec61b_hipsc_train/4/40484/4663 +- sec61b_hipsc_train/4/40960/4625 +- sec61b_hipsc_train/4/40960/4628 +- sec61b_hipsc_train/4/40960/4640 +- sec61b_hipsc_train/4/40960/4654 +- sec61b_hipsc_train/4/40960/4656 +- sec61b_hipsc_train/4/40960/4674 +- sec61b_hipsc_train/4/40960/4678 +- sec61b_hipsc_train/4/40961/4635 +- sec61b_hipsc_train/4/40961/4669 +- sec61b_hipsc_train/4/40962/4676 +- sec61b_hipsc_train/4/40964/4623 +- sec61b_hipsc_train/4/40964/4631 +- sec61b_hipsc_train/4/40964/4649 +- sec61b_hipsc_train/4/40964/4660 +- sec61b_hipsc_train/4/40964/4667 +- sec61b_hipsc_train/4/40964/4672 +- sec61b_hipsc_train/4/41044/4843 +- sec61b_hipsc_train/4/41044/4847 +- sec61b_hipsc_train/4/41044/4851 +- sec61b_hipsc_train/4/41044/4876 +- sec61b_hipsc_train/4/41044/4895 +- sec61b_hipsc_train/4/41045/4853 +- sec61b_hipsc_train/4/41045/4873 +- sec61b_hipsc_train/4/41045/4889 +- sec61b_hipsc_train/4/41045/4893 +- sec61b_hipsc_train/4/41046/4900 +- sec61b_hipsc_train/4/41047/4845 +- sec61b_hipsc_train/4/41047/4882 +- sec61b_hipsc_train/4/41047/4883 +- sec61b_hipsc_train/4/41047/4902 +- sec61b_hipsc_train/4/41057/4860 +- sec61b_hipsc_train/4/41057/4864 +- sec61b_hipsc_train/4/41057/4875 +- sec61b_hipsc_train/4/41057/4877 +- sec61b_hipsc_train/4/41057/4896 +- sec61b_hipsc_train/4/41058/4855 +- sec61b_hipsc_train/4/41058/4879 +- sec61b_hipsc_train/4/41058/4897 +- sec61b_hipsc_train/4/41058/4899 +- sec61b_hipsc_train/4/41059/4841 +- sec61b_hipsc_train/4/41059/4867 +- sec61b_hipsc_train/4/41059/4884 +- sec61b_hipsc_train/4/41059/4888 +- sec61b_hipsc_train/4/41059/4890 +- sec61b_hipsc_train/4/41059/4892 +- sec61b_hipsc_train/4/41060/4859 +- sec61b_hipsc_train/4/41060/4862 +- sec61b_hipsc_train/4/41060/4878 +- sec61b_hipsc_train/4/41060/4880 +- sec61b_hipsc_train/4/41060/4881 +- sec61b_hipsc_train/4/41060/4894 +- sec61b_hipsc_train/4/41060/4898 +- sec61b_hipsc_train/4/41237/4813 +- sec61b_hipsc_train/4/41237/4826 +- sec61b_hipsc_train/4/41237/4840 +- sec61b_hipsc_train/4/41237/4842 +- sec61b_hipsc_train/4/41237/4861 +- sec61b_hipsc_train/4/41237/4865 +- sec61b_hipsc_train/4/41237/4870 +- sec61b_hipsc_train/4/41238/4815 +- sec61b_hipsc_train/4/41238/4816 +- sec61b_hipsc_train/4/41238/4819 +- sec61b_hipsc_train/4/41238/4827 +- sec61b_hipsc_train/4/41238/4839 +- sec61b_hipsc_train/4/41238/4844 +- sec61b_hipsc_train/4/41238/4874 +- sec61b_hipsc_train/4/41239/4817 +- sec61b_hipsc_train/4/41239/4824 +- sec61b_hipsc_train/4/41239/4830 +- sec61b_hipsc_train/4/41239/4833 +- sec61b_hipsc_train/4/41239/4836 +- sec61b_hipsc_train/4/41239/4838 +- sec61b_hipsc_train/4/41240/4814 +- sec61b_hipsc_train/4/41240/4820 +- sec61b_hipsc_train/4/41240/4821 +- sec61b_hipsc_train/4/41240/4825 +- sec61b_hipsc_train/4/41240/4831 +- sec61b_hipsc_train/4/41240/4852 +- sec61b_hipsc_train/4/41240/4858 +- sec61b_hipsc_train/4/41240/4866 +- sec61b_hipsc_train/4/41249/4835 +- sec61b_hipsc_train/4/41249/4837 +- sec61b_hipsc_train/4/41249/4868 +- sec61b_hipsc_train/4/41335/4810 +- sec61b_hipsc_train/4/41347/4804 +- sec61b_hipsc_train/4/41347/4808 +- sec61b_hipsc_train/4/41347/4812 +- sec61b_hipsc_train/4/41348/4805 +- sec61b_hipsc_train/4/41348/4806 +- sec61b_hipsc_train/4/41348/4807 +- sec61b_hipsc_train/4/41348/4811 +- sec61b_hipsc_train/4/41428/4714 +- sec61b_hipsc_train/4/41428/4723 +- sec61b_hipsc_train/4/41428/4737 +- sec61b_hipsc_train/4/41428/4739 +- sec61b_hipsc_train/4/41430/4722 +- sec61b_hipsc_train/4/41430/4732 +- sec61b_hipsc_train/4/41430/4733 +- sec61b_hipsc_train/4/41430/4741 +- sec61b_hipsc_train/4/41430/4742 +- sec61b_hipsc_train/4/41432/4716 +- sec61b_hipsc_train/4/41432/4719 +- sec61b_hipsc_train/4/41432/4720 +- sec61b_hipsc_train/4/41432/4724 +- sec61b_hipsc_train/4/41432/4726 +- sec61b_hipsc_train/4/41432/4740 +- sec61b_hipsc_train/4/41441/4721 +- sec61b_hipsc_train/4/41441/4727 +- sec61b_hipsc_train/4/41441/4728 +- sec61b_hipsc_train/4/41441/4731 +- sec61b_hipsc_train/4/41441/4734 +- sec61b_hipsc_train/4/41441/4735 +- sec61b_hipsc_train/4/41908/5019 +- sec61b_hipsc_train/4/41908/5021 +- sec61b_hipsc_train/4/41908/5043 +- sec61b_hipsc_train/4/41908/5098 +- sec61b_hipsc_train/4/41908/5099 +- sec61b_hipsc_train/4/41909/5025 +- sec61b_hipsc_train/4/41909/5035 +- sec61b_hipsc_train/4/41909/5046 +- sec61b_hipsc_train/4/41909/5082 +- sec61b_hipsc_train/4/41909/5084 +- sec61b_hipsc_train/4/41909/5092 +- sec61b_hipsc_train/4/41909/5096 +- sec61b_hipsc_train/4/41910/5017 +- sec61b_hipsc_train/4/41910/5023 +- sec61b_hipsc_train/4/41910/5033 +- sec61b_hipsc_train/4/41910/5093 +- sec61b_hipsc_train/4/41911/5015 +- sec61b_hipsc_train/4/41911/5029 +- sec61b_hipsc_train/4/41911/5055 +- sec61b_hipsc_train/4/41911/5064 +- sec61b_hipsc_train/4/41911/5079 +- sec61b_hipsc_train/4/41911/5080 +- sec61b_hipsc_train/4/41911/5086 +- sec61b_hipsc_train/4/41911/5094 +- sec61b_hipsc_train/4/41912/5039 +- sec61b_hipsc_train/4/41912/5041 +- sec61b_hipsc_train/4/41912/5052 +- sec61b_hipsc_train/4/41912/5074 +- sec61b_hipsc_train/4/41912/5095 +- sec61b_hipsc_train/4/42197/5020 +- sec61b_hipsc_train/4/42197/5026 +- sec61b_hipsc_train/4/42197/5030 +- sec61b_hipsc_train/4/42197/5036 +- sec61b_hipsc_train/4/42197/5075 +- sec61b_hipsc_train/4/42199/5032 +- sec61b_hipsc_train/4/42199/5045 +- sec61b_hipsc_train/4/42199/5063 +- sec61b_hipsc_train/4/42199/5066 +- sec61b_hipsc_train/4/42199/5069 +- sec61b_hipsc_train/4/42200/5016 +- sec61b_hipsc_train/4/42200/5028 +- sec61b_hipsc_train/4/42200/5038 +- sec61b_hipsc_train/4/42211/5018 +- sec61b_hipsc_train/4/42211/5024 +- sec61b_hipsc_train/4/42211/5051 +- sec61b_hipsc_train/4/42211/5053 +- sec61b_hipsc_train/4/42211/5057 +- sec61b_hipsc_train/42/136118/15182 +- sec61b_hipsc_train/42/136118/15269 +- sec61b_hipsc_train/42/136118/16846 +- sec61b_hipsc_train/42/136119/14226 +- sec61b_hipsc_train/42/136119/14227 +- sec61b_hipsc_train/42/136119/15430 +- sec61b_hipsc_train/42/136119/15573 +- sec61b_hipsc_train/42/136120/15452 +- sec61b_hipsc_train/42/136120/15958 +- sec61b_hipsc_train/42/136120/16873 +- sec61b_hipsc_train/42/136121/15700 +- sec61b_hipsc_train/42/136121/16618 +- sec61b_hipsc_train/42/136121/17149 +- sec61b_hipsc_train/42/136122/16832 +- sec61b_hipsc_train/42/136122/16883 +- sec61b_hipsc_train/42/136122/16987 +- sec61b_hipsc_train/42/136122/17182 +- sec61b_hipsc_train/42/136124/15667 +- sec61b_hipsc_train/42/136124/15715 +- sec61b_hipsc_train/42/136126/15932 +- sec61b_hipsc_train/42/136126/16322 +- sec61b_hipsc_train/42/138024/15523 +- sec61b_hipsc_train/42/138024/15890 +- sec61b_hipsc_train/42/138024/16225 +- sec61b_hipsc_train/42/138024/16287 +- sec61b_hipsc_train/42/138024/16991 +- sec61b_hipsc_train/42/138025/15979 +- sec61b_hipsc_train/42/138025/16227 +- sec61b_hipsc_train/42/138025/16897 +- sec61b_hipsc_train/42/138025/17204 +- sec61b_hipsc_train/42/138025/17241 +- sec61b_hipsc_train/42/138026/15744 +- sec61b_hipsc_train/42/138026/16036 +- sec61b_hipsc_train/42/138026/16240 +- sec61b_hipsc_train/42/138026/17153 +- sec61b_hipsc_train/42/138026/17201 +- sec61b_hipsc_train/42/138026/17206 +- sec61b_hipsc_train/42/138026/17257 +- sec61b_hipsc_train/42/138027/17190 +- sec61b_hipsc_train/42/138027/17231 +- sec61b_hipsc_train/42/138027/17262 +- sec61b_hipsc_train/42/138028/15886 +- sec61b_hipsc_train/42/138028/16174 +- sec61b_hipsc_train/42/138028/16396 +- sec61b_hipsc_train/42/138028/17142 +- sec61b_hipsc_train/42/138028/17192 +- sec61b_hipsc_train/42/138028/17244 +- sec61b_hipsc_train/42/138030/15632 +- sec61b_hipsc_train/42/138030/15792 +- sec61b_hipsc_train/42/138030/15894 +- sec61b_hipsc_train/42/138032/15614 +- sec61b_hipsc_train/42/138032/15851 +- sec61b_hipsc_train/42/138032/16266 +- sec61b_hipsc_train/42/138032/16928 +- sec61b_hipsc_train/42/138032/17205 +- sec61b_hipsc_train/42/138032/17209 +- sec61b_hipsc_train/42/138033/17171 +- sec61b_hipsc_train/42/138033/17255 +- sec61b_hipsc_train/42/138037/15612 +- sec61b_hipsc_train/42/138037/16696 +- sec61b_hipsc_train/42/138037/17203 +- sec61b_hipsc_train/42/138037/17223 +- sec61b_hipsc_train/42/138044/15587 +- sec61b_hipsc_train/42/138044/16757 +- sec61b_hipsc_train/42/138044/17236 +- sec61b_hipsc_train/42/138045/15540 +- sec61b_hipsc_train/42/138045/15558 +- sec61b_hipsc_train/42/138045/15684 +- sec61b_hipsc_train/42/138045/15786 +- sec61b_hipsc_train/42/138045/16126 +- sec61b_hipsc_train/42/138045/16159 +- sec61b_hipsc_train/42/138045/16598 +- sec61b_hipsc_train/42/138045/17164 +- sec61b_hipsc_train/42/138045/17234 +- sec61b_hipsc_train/42/138045/17242 +- sec61b_hipsc_train/42/138045/17256 +- sec61b_hipsc_train/42/138247/17207 +- sec61b_hipsc_train/42/138249/16356 +- sec61b_hipsc_train/42/138249/17200 +- sec61b_hipsc_train/42/138251/15688 +- sec61b_hipsc_train/42/138251/15760 +- sec61b_hipsc_train/42/138251/15918 +- sec61b_hipsc_train/42/138251/16722 +- sec61b_hipsc_train/42/138251/16982 +- sec61b_hipsc_train/42/138251/17191 +- sec61b_hipsc_train/42/138253/15957 +- sec61b_hipsc_train/42/138253/16263 +- sec61b_hipsc_train/42/138253/16587 +- sec61b_hipsc_train/42/138253/16799 +- sec61b_hipsc_train/42/138253/16955 +- sec61b_hipsc_train/42/138257/16247 +- sec61b_hipsc_train/42/138257/16292 +- sec61b_hipsc_train/42/138257/16306 +- sec61b_hipsc_train/42/138257/16480 +- sec61b_hipsc_train/42/138257/17221 +- sec61b_hipsc_train/42/138261/15887 +- sec61b_hipsc_train/42/138261/16083 +- sec61b_hipsc_train/42/138261/16860 +- sec61b_a549_mantis_2024_10_31_train/C/2/000000 +- sec61b_a549_mantis_2024_10_31_train/C/2/000001 +- sec61b_a549_mantis_2024_10_31_train/C/2/001000 +- sec61b_a549_mantis_2024_10_31_train/C/2/001001 +- sec61b_a549_mantis_2024_10_31_train/C/2/002000 +- sec61b_a549_mantis_2024_10_31_train/C/2/002001 +- sec61b_a549_mantis_2024_10_31_train/C/4/002000 +- sec61b_a549_mantis_2024_10_31_train/C/4/002001 +- sec61b_a549_mantis_2024_11_07_train/B/1/001000 +- sec61b_a549_mantis_2024_11_07_train/B/1/001001 +- sec61b_a549_mantis_2024_11_07_train/B/3/001000 +- sec61b_a549_mantis_2024_11_07_train/B/3/001001 +- sec61b_a549_mantis_2025_07_24_train/A/1/002000 +- sec61b_a549_mantis_2025_07_24_train/A/1/002001 +- sec61b_a549_mantis_2025_08_26_train/A/1/001001 +- sec61b_a549_mantis_2025_08_26_train/A/1/001002 +- sec61b_a549_mantis_2025_08_26_train/A/1/002000 +- sec61b_a549_mantis_2025_08_26_train/A/1/002001 +- sec61b_a549_mantis_2025_08_26_train/A/1/002002 +- sec61b_a549_mantis_2025_08_26_train/B/1/002000 +- sec61b_a549_mantis_2025_08_26_train/B/1/002001 +- sec61b_a549_mantis_2025_08_26_train/B/1/002002 +test_fovs: +- sec61b_hipsc_test/4/38452/5187 +- sec61b_hipsc_test/4/38452/5201 +- sec61b_hipsc_test/4/38452/5203 +- sec61b_hipsc_test/4/38464/5173 +- sec61b_hipsc_test/4/38465/5189 +- sec61b_hipsc_test/4/38466/5200 +- sec61b_hipsc_test/4/39124/5286 +- sec61b_hipsc_test/4/39125/5224 +- sec61b_hipsc_test/4/39126/5289 +- sec61b_hipsc_test/4/39128/5230 +- sec61b_hipsc_test/4/39128/5254 +- sec61b_hipsc_test/4/39137/5252 +- sec61b_hipsc_test/4/39138/5268 +- sec61b_hipsc_test/4/39140/5293 +- sec61b_hipsc_test/4/39222/5281 +- sec61b_hipsc_test/4/39222/5311 +- sec61b_hipsc_test/4/39232/5329 +- sec61b_hipsc_test/4/39233/5304 +- sec61b_hipsc_test/4/39233/5313 +- sec61b_hipsc_test/4/39233/5327 +- sec61b_hipsc_test/4/39236/5305 +- sec61b_hipsc_test/4/40084/5357 +- sec61b_hipsc_test/4/40084/5415 +- sec61b_hipsc_test/4/40085/5421 +- sec61b_hipsc_test/4/40086/5362 +- sec61b_hipsc_test/4/40181/5434 +- sec61b_hipsc_test/4/40181/5451 +- sec61b_hipsc_test/4/40181/5453 +- sec61b_hipsc_test/4/40195/5479 +- sec61b_hipsc_test/4/40196/5471 +- sec61b_hipsc_test/4/40375/4612 +- sec61b_hipsc_test/4/40376/4568 +- sec61b_hipsc_test/4/40376/4601 +- sec61b_hipsc_test/4/40376/4604 +- sec61b_hipsc_test/4/40385/4565 +- sec61b_hipsc_test/4/40385/4572 +- sec61b_hipsc_test/4/40385/4576 +- sec61b_hipsc_test/4/40385/4610 +- sec61b_hipsc_test/4/40386/4603 +- sec61b_hipsc_test/4/40386/4606 +- sec61b_hipsc_test/4/40387/4570 +- sec61b_hipsc_test/4/40388/4591 +- sec61b_hipsc_test/4/40468/4624 +- sec61b_hipsc_test/4/40471/4659 +- sec61b_hipsc_test/4/40471/4661 +- sec61b_hipsc_test/4/40471/4679 +- sec61b_hipsc_test/4/40481/4627 +- sec61b_hipsc_test/4/40483/4621 +- sec61b_hipsc_test/4/40483/4637 +- sec61b_hipsc_test/4/40483/4644 +- sec61b_hipsc_test/4/40960/4630 +- sec61b_hipsc_test/4/40961/4665 +- sec61b_hipsc_test/4/40964/4643 +- sec61b_hipsc_test/4/41044/4869 +- sec61b_hipsc_test/4/41044/4891 +- sec61b_hipsc_test/4/41046/4849 +- sec61b_hipsc_test/4/41047/4885 +- sec61b_hipsc_test/4/41057/4887 +- sec61b_hipsc_test/4/41059/4886 +- sec61b_hipsc_test/4/41060/4901 +- sec61b_hipsc_test/4/41238/4828 +- sec61b_hipsc_test/4/41239/4823 +- sec61b_hipsc_test/4/41239/4832 +- sec61b_hipsc_test/4/41240/4818 +- sec61b_hipsc_test/4/41240/4834 +- sec61b_hipsc_test/4/41335/4803 +- sec61b_hipsc_test/4/41348/4809 +- sec61b_hipsc_test/4/41428/4713 +- sec61b_hipsc_test/4/41428/4718 +- sec61b_hipsc_test/4/41428/4743 +- sec61b_hipsc_test/4/41430/4744 +- sec61b_hipsc_test/4/41432/4729 +- sec61b_hipsc_test/4/41441/4725 +- sec61b_hipsc_test/4/41908/5037 +- sec61b_hipsc_test/4/41908/5061 +- sec61b_hipsc_test/4/41909/5071 +- sec61b_hipsc_test/4/41910/5031 +- sec61b_hipsc_test/4/41910/5058 +- sec61b_hipsc_test/4/41910/5088 +- sec61b_hipsc_test/4/41911/5027 +- sec61b_hipsc_test/4/42199/5048 +- sec61b_hipsc_test/4/42211/5034 +- sec61b_hipsc_test/42/136118/14223 +- sec61b_hipsc_test/42/136118/14225 +- sec61b_hipsc_test/42/136118/16503 +- sec61b_hipsc_test/42/136119/16504 +- sec61b_hipsc_test/42/136120/14221 +- sec61b_hipsc_test/42/136120/14224 +- sec61b_hipsc_test/42/136120/14228 +- sec61b_hipsc_test/42/136120/15747 +- sec61b_hipsc_test/42/136124/16127 +- sec61b_hipsc_test/42/138024/17222 +- sec61b_hipsc_test/42/138026/17232 +- sec61b_hipsc_test/42/138028/15839 +- sec61b_hipsc_test/42/138028/17202 +- sec61b_hipsc_test/42/138032/15577 +- sec61b_hipsc_test/42/138044/15777 +- sec61b_hipsc_test/42/138045/16692 +- sec61b_hipsc_test/42/138251/17249 +- sec61b_hipsc_test/42/138253/15966 +- sec61b_a549_mantis_2024_10_31_test/C/4/000000 +- sec61b_a549_mantis_2024_10_31_test/C/4/000001 +- sec61b_a549_mantis_2024_10_31_test/C/4/001000 +- sec61b_a549_mantis_2024_10_31_test/C/4/001001 +- sec61b_a549_mantis_2024_11_07_test/B/1/000000 +- sec61b_a549_mantis_2024_11_07_test/B/1/000001 +- sec61b_a549_mantis_2024_11_07_test/B/2/000000 +- sec61b_a549_mantis_2024_11_07_test/B/2/000001 +- sec61b_a549_mantis_2024_11_07_test/B/2/001000 +- sec61b_a549_mantis_2024_11_07_test/B/2/001001 +- sec61b_a549_mantis_2024_11_07_test/B/3/000000 +- sec61b_a549_mantis_2024_11_07_test/B/3/000001 +- sec61b_a549_mantis_2024_11_07_test/C/2/000000 +- sec61b_a549_mantis_2024_11_07_test/C/2/000001 +- sec61b_a549_mantis_2024_11_07_test/C/2/001000 +- sec61b_a549_mantis_2024_11_07_test/C/2/001001 +- sec61b_a549_mantis_2025_07_24_test/A/1/000000 +- sec61b_a549_mantis_2025_07_24_test/A/1/000001 +- sec61b_a549_mantis_2025_07_24_test/A/1/001000 +- sec61b_a549_mantis_2025_07_24_test/A/1/001001 +- sec61b_a549_mantis_2025_07_24_test/A/2/000000 +- sec61b_a549_mantis_2025_07_24_test/A/2/000001 +- sec61b_a549_mantis_2025_07_24_test/A/2/001000 +- sec61b_a549_mantis_2025_07_24_test/A/2/001001 +- sec61b_a549_mantis_2025_07_24_test/A/2/002000 +- sec61b_a549_mantis_2025_07_24_test/A/2/002001 +- sec61b_a549_mantis_2025_08_26_test/A/1/000000 +- sec61b_a549_mantis_2025_08_26_test/A/1/000001 +- sec61b_a549_mantis_2025_08_26_test/A/1/000002 +- sec61b_a549_mantis_2025_08_26_test/A/1/001000 +- sec61b_a549_mantis_2025_08_26_test/B/1/000000 +- sec61b_a549_mantis_2025_08_26_test/B/1/000001 +- sec61b_a549_mantis_2025_08_26_test/B/1/000002 +- sec61b_a549_mantis_2025_08_26_test/B/1/001000 +- sec61b_a549_mantis_2025_08_26_test/B/1/001001 +- sec61b_a549_mantis_2025_08_26_test/B/1/001002 diff --git a/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/sec61b_joint_mock_v1.yaml b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/sec61b_joint_mock_v1.yaml new file mode 100644 index 000000000..24f70cd76 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/sec61b_joint_mock_v1.yaml @@ -0,0 +1,731 @@ +name: sec61b_joint_mock_v1 +description: Joint frozen benchmark collection for target 'sec61b' with condition + filter 'mock' across 4 source datasets. Channels and FOV membership captured from + the live train/test zarr stores at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-24T19:47:08.661967+00:00' + created_by: Alex Kalinin +experiments: +- name: sec61b_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/SEC61B.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: SEC61B + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: sec61b_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/SEC61B.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: SEC61B + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: sec61b_a549_mantis_2024_11_07_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_07_A549_SEC61_DENV/train/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2024_11_07_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_07_A549_SEC61_DENV/test/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2025_07_24_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV/train/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2025_07_24_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV/test/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2025_08_26_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_08_26_A549_SEC61_TOMM20_ZIKV/train/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: sec61b_a549_mantis_2025_08_26_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_08_26_A549_SEC61_TOMM20_ZIKV/test/SEC61B.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: SEC61B + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: SEC61B + organelle: er + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +train_fovs: +- sec61b_hipsc_train/4/38452/5161 +- sec61b_hipsc_train/4/38452/5165 +- sec61b_hipsc_train/4/38452/5177 +- sec61b_hipsc_train/4/38452/5184 +- sec61b_hipsc_train/4/38452/5194 +- sec61b_hipsc_train/4/38452/5198 +- sec61b_hipsc_train/4/38464/5157 +- sec61b_hipsc_train/4/38464/5159 +- sec61b_hipsc_train/4/38464/5176 +- sec61b_hipsc_train/4/38464/5179 +- sec61b_hipsc_train/4/38464/5181 +- sec61b_hipsc_train/4/38464/5186 +- sec61b_hipsc_train/4/38464/5190 +- sec61b_hipsc_train/4/38464/5199 +- sec61b_hipsc_train/4/38464/5202 +- sec61b_hipsc_train/4/38465/5164 +- sec61b_hipsc_train/4/38465/5171 +- sec61b_hipsc_train/4/38465/5191 +- sec61b_hipsc_train/4/38465/5195 +- sec61b_hipsc_train/4/38465/5197 +- sec61b_hipsc_train/4/38466/5155 +- sec61b_hipsc_train/4/38466/5168 +- sec61b_hipsc_train/4/38466/5188 +- sec61b_hipsc_train/4/38466/5192 +- sec61b_hipsc_train/4/38466/5193 +- sec61b_hipsc_train/4/38466/5196 +- sec61b_hipsc_train/4/39124/5221 +- sec61b_hipsc_train/4/39124/5223 +- sec61b_hipsc_train/4/39124/5247 +- sec61b_hipsc_train/4/39124/5258 +- sec61b_hipsc_train/4/39124/5280 +- sec61b_hipsc_train/4/39125/5264 +- sec61b_hipsc_train/4/39126/5229 +- sec61b_hipsc_train/4/39127/5283 +- sec61b_hipsc_train/4/39128/5219 +- sec61b_hipsc_train/4/39128/5260 +- sec61b_hipsc_train/4/39128/5272 +- sec61b_hipsc_train/4/39136/5225 +- sec61b_hipsc_train/4/39136/5234 +- sec61b_hipsc_train/4/39136/5236 +- sec61b_hipsc_train/4/39136/5239 +- sec61b_hipsc_train/4/39137/5243 +- sec61b_hipsc_train/4/39137/5266 +- sec61b_hipsc_train/4/39137/5274 +- sec61b_hipsc_train/4/39137/5277 +- sec61b_hipsc_train/4/39138/5256 +- sec61b_hipsc_train/4/39138/5262 +- sec61b_hipsc_train/4/39138/5270 +- sec61b_hipsc_train/4/39139/5220 +- sec61b_hipsc_train/4/39139/5244 +- sec61b_hipsc_train/4/39139/5249 +- sec61b_hipsc_train/4/39139/5250 +- sec61b_hipsc_train/4/39140/5222 +- sec61b_hipsc_train/4/39140/5232 +- sec61b_hipsc_train/4/39140/5240 +- sec61b_hipsc_train/4/39222/5288 +- sec61b_hipsc_train/4/39222/5291 +- sec61b_hipsc_train/4/39222/5298 +- sec61b_hipsc_train/4/39222/5303 +- sec61b_hipsc_train/4/39222/5324 +- sec61b_hipsc_train/4/39224/5294 +- sec61b_hipsc_train/4/39224/5302 +- sec61b_hipsc_train/4/39224/5307 +- sec61b_hipsc_train/4/39224/5321 +- sec61b_hipsc_train/4/39224/5326 +- sec61b_hipsc_train/4/39224/5332 +- sec61b_hipsc_train/4/39232/5278 +- sec61b_hipsc_train/4/39232/5318 +- sec61b_hipsc_train/4/39232/5323 +- sec61b_hipsc_train/4/39232/5330 +- sec61b_hipsc_train/4/39233/5299 +- sec61b_hipsc_train/4/39233/5309 +- sec61b_hipsc_train/4/39233/5322 +- sec61b_hipsc_train/4/39236/5316 +- sec61b_hipsc_train/4/39236/5317 +- sec61b_hipsc_train/4/40084/5359 +- sec61b_hipsc_train/4/40084/5380 +- sec61b_hipsc_train/4/40084/5407 +- sec61b_hipsc_train/4/40084/5429 +- sec61b_hipsc_train/4/40085/5371 +- sec61b_hipsc_train/4/40085/5383 +- sec61b_hipsc_train/4/40085/5389 +- sec61b_hipsc_train/4/40086/5401 +- sec61b_hipsc_train/4/40087/5377 +- sec61b_hipsc_train/4/40087/5405 +- sec61b_hipsc_train/4/40087/5428 +- sec61b_hipsc_train/4/40088/5365 +- sec61b_hipsc_train/4/40088/5368 +- sec61b_hipsc_train/4/40088/5392 +- sec61b_hipsc_train/4/40088/5398 +- sec61b_hipsc_train/4/40088/5403 +- sec61b_hipsc_train/4/40088/5417 +- sec61b_hipsc_train/4/40088/5422 +- sec61b_hipsc_train/4/40088/5424 +- sec61b_hipsc_train/4/40088/5430 +- sec61b_hipsc_train/4/40098/5386 +- sec61b_hipsc_train/4/40098/5409 +- sec61b_hipsc_train/4/40098/5427 +- sec61b_hipsc_train/4/40180/5447 +- sec61b_hipsc_train/4/40180/5461 +- sec61b_hipsc_train/4/40180/5475 +- sec61b_hipsc_train/4/40180/5497 +- sec61b_hipsc_train/4/40181/5435 +- sec61b_hipsc_train/4/40181/5441 +- sec61b_hipsc_train/4/40181/5443 +- sec61b_hipsc_train/4/40181/5481 +- sec61b_hipsc_train/4/40182/5432 +- sec61b_hipsc_train/4/40182/5433 +- sec61b_hipsc_train/4/40182/5455 +- sec61b_hipsc_train/4/40182/5498 +- sec61b_hipsc_train/4/40184/5439 +- sec61b_hipsc_train/4/40184/5457 +- sec61b_hipsc_train/4/40194/5459 +- sec61b_hipsc_train/4/40194/5463 +- sec61b_hipsc_train/4/40195/5436 +- sec61b_hipsc_train/4/40195/5483 +- sec61b_hipsc_train/4/40195/5489 +- sec61b_hipsc_train/4/40195/5491 +- sec61b_hipsc_train/4/40375/4566 +- sec61b_hipsc_train/4/40375/4599 +- sec61b_hipsc_train/4/40375/4608 +- sec61b_hipsc_train/4/40376/4563 +- sec61b_hipsc_train/4/40376/4584 +- sec61b_hipsc_train/4/40376/4605 +- sec61b_hipsc_train/4/40376/4607 +- sec61b_hipsc_train/4/40376/4609 +- sec61b_hipsc_train/4/40385/4557 +- sec61b_hipsc_train/4/40385/4559 +- sec61b_hipsc_train/4/40385/4578 +- sec61b_hipsc_train/4/40385/4593 +- sec61b_hipsc_train/4/40385/4614 +- sec61b_hipsc_train/4/40386/4580 +- sec61b_hipsc_train/4/40386/4611 +- sec61b_hipsc_train/4/40386/4613 +- sec61b_hipsc_train/4/40387/4561 +- sec61b_hipsc_train/4/40387/4582 +- sec61b_hipsc_train/4/40387/4586 +- sec61b_hipsc_train/4/40387/4595 +- sec61b_hipsc_train/4/40387/4597 +- sec61b_hipsc_train/4/40388/4574 +- sec61b_hipsc_train/4/40388/4588 +- sec61b_hipsc_train/4/40468/4620 +- sec61b_hipsc_train/4/40468/4650 +- sec61b_hipsc_train/4/40468/4653 +- sec61b_hipsc_train/4/40468/4655 +- sec61b_hipsc_train/4/40469/4641 +- sec61b_hipsc_train/4/40469/4666 +- sec61b_hipsc_train/4/40469/4673 +- sec61b_hipsc_train/4/40470/4615 +- sec61b_hipsc_train/4/40470/4616 +- sec61b_hipsc_train/4/40470/4671 +- sec61b_hipsc_train/4/40470/4675 +- sec61b_hipsc_train/4/40470/4677 +- sec61b_hipsc_train/4/40471/4632 +- sec61b_hipsc_train/4/40471/4657 +- sec61b_hipsc_train/4/40471/4664 +- sec61b_hipsc_train/4/40481/4622 +- sec61b_hipsc_train/4/40481/4633 +- sec61b_hipsc_train/4/40481/4647 +- sec61b_hipsc_train/4/40481/4668 +- sec61b_hipsc_train/4/40483/4617 +- sec61b_hipsc_train/4/40483/4619 +- sec61b_hipsc_train/4/40483/4629 +- sec61b_hipsc_train/4/40484/4618 +- sec61b_hipsc_train/4/40484/4626 +- sec61b_hipsc_train/4/40484/4663 +- sec61b_hipsc_train/4/40960/4625 +- sec61b_hipsc_train/4/40960/4628 +- sec61b_hipsc_train/4/40960/4640 +- sec61b_hipsc_train/4/40960/4654 +- sec61b_hipsc_train/4/40960/4656 +- sec61b_hipsc_train/4/40960/4674 +- sec61b_hipsc_train/4/40960/4678 +- sec61b_hipsc_train/4/40961/4635 +- sec61b_hipsc_train/4/40961/4669 +- sec61b_hipsc_train/4/40962/4676 +- sec61b_hipsc_train/4/40964/4623 +- sec61b_hipsc_train/4/40964/4631 +- sec61b_hipsc_train/4/40964/4649 +- sec61b_hipsc_train/4/40964/4660 +- sec61b_hipsc_train/4/40964/4667 +- sec61b_hipsc_train/4/40964/4672 +- sec61b_hipsc_train/4/41044/4843 +- sec61b_hipsc_train/4/41044/4847 +- sec61b_hipsc_train/4/41044/4851 +- sec61b_hipsc_train/4/41044/4876 +- sec61b_hipsc_train/4/41044/4895 +- sec61b_hipsc_train/4/41045/4853 +- sec61b_hipsc_train/4/41045/4873 +- sec61b_hipsc_train/4/41045/4889 +- sec61b_hipsc_train/4/41045/4893 +- sec61b_hipsc_train/4/41046/4900 +- sec61b_hipsc_train/4/41047/4845 +- sec61b_hipsc_train/4/41047/4882 +- sec61b_hipsc_train/4/41047/4883 +- sec61b_hipsc_train/4/41047/4902 +- sec61b_hipsc_train/4/41057/4860 +- sec61b_hipsc_train/4/41057/4864 +- sec61b_hipsc_train/4/41057/4875 +- sec61b_hipsc_train/4/41057/4877 +- sec61b_hipsc_train/4/41057/4896 +- sec61b_hipsc_train/4/41058/4855 +- sec61b_hipsc_train/4/41058/4879 +- sec61b_hipsc_train/4/41058/4897 +- sec61b_hipsc_train/4/41058/4899 +- sec61b_hipsc_train/4/41059/4841 +- sec61b_hipsc_train/4/41059/4867 +- sec61b_hipsc_train/4/41059/4884 +- sec61b_hipsc_train/4/41059/4888 +- sec61b_hipsc_train/4/41059/4890 +- sec61b_hipsc_train/4/41059/4892 +- sec61b_hipsc_train/4/41060/4859 +- sec61b_hipsc_train/4/41060/4862 +- sec61b_hipsc_train/4/41060/4878 +- sec61b_hipsc_train/4/41060/4880 +- sec61b_hipsc_train/4/41060/4881 +- sec61b_hipsc_train/4/41060/4894 +- sec61b_hipsc_train/4/41060/4898 +- sec61b_hipsc_train/4/41237/4813 +- sec61b_hipsc_train/4/41237/4826 +- sec61b_hipsc_train/4/41237/4840 +- sec61b_hipsc_train/4/41237/4842 +- sec61b_hipsc_train/4/41237/4861 +- sec61b_hipsc_train/4/41237/4865 +- sec61b_hipsc_train/4/41237/4870 +- sec61b_hipsc_train/4/41238/4815 +- sec61b_hipsc_train/4/41238/4816 +- sec61b_hipsc_train/4/41238/4819 +- sec61b_hipsc_train/4/41238/4827 +- sec61b_hipsc_train/4/41238/4839 +- sec61b_hipsc_train/4/41238/4844 +- sec61b_hipsc_train/4/41238/4874 +- sec61b_hipsc_train/4/41239/4817 +- sec61b_hipsc_train/4/41239/4824 +- sec61b_hipsc_train/4/41239/4830 +- sec61b_hipsc_train/4/41239/4833 +- sec61b_hipsc_train/4/41239/4836 +- sec61b_hipsc_train/4/41239/4838 +- sec61b_hipsc_train/4/41240/4814 +- sec61b_hipsc_train/4/41240/4820 +- sec61b_hipsc_train/4/41240/4821 +- sec61b_hipsc_train/4/41240/4825 +- sec61b_hipsc_train/4/41240/4831 +- sec61b_hipsc_train/4/41240/4852 +- sec61b_hipsc_train/4/41240/4858 +- sec61b_hipsc_train/4/41240/4866 +- sec61b_hipsc_train/4/41249/4835 +- sec61b_hipsc_train/4/41249/4837 +- sec61b_hipsc_train/4/41249/4868 +- sec61b_hipsc_train/4/41335/4810 +- sec61b_hipsc_train/4/41347/4804 +- sec61b_hipsc_train/4/41347/4808 +- sec61b_hipsc_train/4/41347/4812 +- sec61b_hipsc_train/4/41348/4805 +- sec61b_hipsc_train/4/41348/4806 +- sec61b_hipsc_train/4/41348/4807 +- sec61b_hipsc_train/4/41348/4811 +- sec61b_hipsc_train/4/41428/4714 +- sec61b_hipsc_train/4/41428/4723 +- sec61b_hipsc_train/4/41428/4737 +- sec61b_hipsc_train/4/41428/4739 +- sec61b_hipsc_train/4/41430/4722 +- sec61b_hipsc_train/4/41430/4732 +- sec61b_hipsc_train/4/41430/4733 +- sec61b_hipsc_train/4/41430/4741 +- sec61b_hipsc_train/4/41430/4742 +- sec61b_hipsc_train/4/41432/4716 +- sec61b_hipsc_train/4/41432/4719 +- sec61b_hipsc_train/4/41432/4720 +- sec61b_hipsc_train/4/41432/4724 +- sec61b_hipsc_train/4/41432/4726 +- sec61b_hipsc_train/4/41432/4740 +- sec61b_hipsc_train/4/41441/4721 +- sec61b_hipsc_train/4/41441/4727 +- sec61b_hipsc_train/4/41441/4728 +- sec61b_hipsc_train/4/41441/4731 +- sec61b_hipsc_train/4/41441/4734 +- sec61b_hipsc_train/4/41441/4735 +- sec61b_hipsc_train/4/41908/5019 +- sec61b_hipsc_train/4/41908/5021 +- sec61b_hipsc_train/4/41908/5043 +- sec61b_hipsc_train/4/41908/5098 +- sec61b_hipsc_train/4/41908/5099 +- sec61b_hipsc_train/4/41909/5025 +- sec61b_hipsc_train/4/41909/5035 +- sec61b_hipsc_train/4/41909/5046 +- sec61b_hipsc_train/4/41909/5082 +- sec61b_hipsc_train/4/41909/5084 +- sec61b_hipsc_train/4/41909/5092 +- sec61b_hipsc_train/4/41909/5096 +- sec61b_hipsc_train/4/41910/5017 +- sec61b_hipsc_train/4/41910/5023 +- sec61b_hipsc_train/4/41910/5033 +- sec61b_hipsc_train/4/41910/5093 +- sec61b_hipsc_train/4/41911/5015 +- sec61b_hipsc_train/4/41911/5029 +- sec61b_hipsc_train/4/41911/5055 +- sec61b_hipsc_train/4/41911/5064 +- sec61b_hipsc_train/4/41911/5079 +- sec61b_hipsc_train/4/41911/5080 +- sec61b_hipsc_train/4/41911/5086 +- sec61b_hipsc_train/4/41911/5094 +- sec61b_hipsc_train/4/41912/5039 +- sec61b_hipsc_train/4/41912/5041 +- sec61b_hipsc_train/4/41912/5052 +- sec61b_hipsc_train/4/41912/5074 +- sec61b_hipsc_train/4/41912/5095 +- sec61b_hipsc_train/4/42197/5020 +- sec61b_hipsc_train/4/42197/5026 +- sec61b_hipsc_train/4/42197/5030 +- sec61b_hipsc_train/4/42197/5036 +- sec61b_hipsc_train/4/42197/5075 +- sec61b_hipsc_train/4/42199/5032 +- sec61b_hipsc_train/4/42199/5045 +- sec61b_hipsc_train/4/42199/5063 +- sec61b_hipsc_train/4/42199/5066 +- sec61b_hipsc_train/4/42199/5069 +- sec61b_hipsc_train/4/42200/5016 +- sec61b_hipsc_train/4/42200/5028 +- sec61b_hipsc_train/4/42200/5038 +- sec61b_hipsc_train/4/42211/5018 +- sec61b_hipsc_train/4/42211/5024 +- sec61b_hipsc_train/4/42211/5051 +- sec61b_hipsc_train/4/42211/5053 +- sec61b_hipsc_train/4/42211/5057 +- sec61b_hipsc_train/42/136118/15182 +- sec61b_hipsc_train/42/136118/15269 +- sec61b_hipsc_train/42/136118/16846 +- sec61b_hipsc_train/42/136119/14226 +- sec61b_hipsc_train/42/136119/14227 +- sec61b_hipsc_train/42/136119/15430 +- sec61b_hipsc_train/42/136119/15573 +- sec61b_hipsc_train/42/136120/15452 +- sec61b_hipsc_train/42/136120/15958 +- sec61b_hipsc_train/42/136120/16873 +- sec61b_hipsc_train/42/136121/15700 +- sec61b_hipsc_train/42/136121/16618 +- sec61b_hipsc_train/42/136121/17149 +- sec61b_hipsc_train/42/136122/16832 +- sec61b_hipsc_train/42/136122/16883 +- sec61b_hipsc_train/42/136122/16987 +- sec61b_hipsc_train/42/136122/17182 +- sec61b_hipsc_train/42/136124/15667 +- sec61b_hipsc_train/42/136124/15715 +- sec61b_hipsc_train/42/136126/15932 +- sec61b_hipsc_train/42/136126/16322 +- sec61b_hipsc_train/42/138024/15523 +- sec61b_hipsc_train/42/138024/15890 +- sec61b_hipsc_train/42/138024/16225 +- sec61b_hipsc_train/42/138024/16287 +- sec61b_hipsc_train/42/138024/16991 +- sec61b_hipsc_train/42/138025/15979 +- sec61b_hipsc_train/42/138025/16227 +- sec61b_hipsc_train/42/138025/16897 +- sec61b_hipsc_train/42/138025/17204 +- sec61b_hipsc_train/42/138025/17241 +- sec61b_hipsc_train/42/138026/15744 +- sec61b_hipsc_train/42/138026/16036 +- sec61b_hipsc_train/42/138026/16240 +- sec61b_hipsc_train/42/138026/17153 +- sec61b_hipsc_train/42/138026/17201 +- sec61b_hipsc_train/42/138026/17206 +- sec61b_hipsc_train/42/138026/17257 +- sec61b_hipsc_train/42/138027/17190 +- sec61b_hipsc_train/42/138027/17231 +- sec61b_hipsc_train/42/138027/17262 +- sec61b_hipsc_train/42/138028/15886 +- sec61b_hipsc_train/42/138028/16174 +- sec61b_hipsc_train/42/138028/16396 +- sec61b_hipsc_train/42/138028/17142 +- sec61b_hipsc_train/42/138028/17192 +- sec61b_hipsc_train/42/138028/17244 +- sec61b_hipsc_train/42/138030/15632 +- sec61b_hipsc_train/42/138030/15792 +- sec61b_hipsc_train/42/138030/15894 +- sec61b_hipsc_train/42/138032/15614 +- sec61b_hipsc_train/42/138032/15851 +- sec61b_hipsc_train/42/138032/16266 +- sec61b_hipsc_train/42/138032/16928 +- sec61b_hipsc_train/42/138032/17205 +- sec61b_hipsc_train/42/138032/17209 +- sec61b_hipsc_train/42/138033/17171 +- sec61b_hipsc_train/42/138033/17255 +- sec61b_hipsc_train/42/138037/15612 +- sec61b_hipsc_train/42/138037/16696 +- sec61b_hipsc_train/42/138037/17203 +- sec61b_hipsc_train/42/138037/17223 +- sec61b_hipsc_train/42/138044/15587 +- sec61b_hipsc_train/42/138044/16757 +- sec61b_hipsc_train/42/138044/17236 +- sec61b_hipsc_train/42/138045/15540 +- sec61b_hipsc_train/42/138045/15558 +- sec61b_hipsc_train/42/138045/15684 +- sec61b_hipsc_train/42/138045/15786 +- sec61b_hipsc_train/42/138045/16126 +- sec61b_hipsc_train/42/138045/16159 +- sec61b_hipsc_train/42/138045/16598 +- sec61b_hipsc_train/42/138045/17164 +- sec61b_hipsc_train/42/138045/17234 +- sec61b_hipsc_train/42/138045/17242 +- sec61b_hipsc_train/42/138045/17256 +- sec61b_hipsc_train/42/138247/17207 +- sec61b_hipsc_train/42/138249/16356 +- sec61b_hipsc_train/42/138249/17200 +- sec61b_hipsc_train/42/138251/15688 +- sec61b_hipsc_train/42/138251/15760 +- sec61b_hipsc_train/42/138251/15918 +- sec61b_hipsc_train/42/138251/16722 +- sec61b_hipsc_train/42/138251/16982 +- sec61b_hipsc_train/42/138251/17191 +- sec61b_hipsc_train/42/138253/15957 +- sec61b_hipsc_train/42/138253/16263 +- sec61b_hipsc_train/42/138253/16587 +- sec61b_hipsc_train/42/138253/16799 +- sec61b_hipsc_train/42/138253/16955 +- sec61b_hipsc_train/42/138257/16247 +- sec61b_hipsc_train/42/138257/16292 +- sec61b_hipsc_train/42/138257/16306 +- sec61b_hipsc_train/42/138257/16480 +- sec61b_hipsc_train/42/138257/17221 +- sec61b_hipsc_train/42/138261/15887 +- sec61b_hipsc_train/42/138261/16083 +- sec61b_hipsc_train/42/138261/16860 +- sec61b_a549_mantis_2024_11_07_train/B/1/001000 +- sec61b_a549_mantis_2024_11_07_train/B/1/001001 +- sec61b_a549_mantis_2024_11_07_train/B/3/001000 +- sec61b_a549_mantis_2024_11_07_train/B/3/001001 +- sec61b_a549_mantis_2025_07_24_train/A/1/002000 +- sec61b_a549_mantis_2025_07_24_train/A/1/002001 +- sec61b_a549_mantis_2025_08_26_train/A/1/001001 +- sec61b_a549_mantis_2025_08_26_train/A/1/001002 +- sec61b_a549_mantis_2025_08_26_train/A/1/002000 +- sec61b_a549_mantis_2025_08_26_train/A/1/002001 +- sec61b_a549_mantis_2025_08_26_train/A/1/002002 +test_fovs: +- sec61b_hipsc_test/4/38452/5187 +- sec61b_hipsc_test/4/38452/5201 +- sec61b_hipsc_test/4/38452/5203 +- sec61b_hipsc_test/4/38464/5173 +- sec61b_hipsc_test/4/38465/5189 +- sec61b_hipsc_test/4/38466/5200 +- sec61b_hipsc_test/4/39124/5286 +- sec61b_hipsc_test/4/39125/5224 +- sec61b_hipsc_test/4/39126/5289 +- sec61b_hipsc_test/4/39128/5230 +- sec61b_hipsc_test/4/39128/5254 +- sec61b_hipsc_test/4/39137/5252 +- sec61b_hipsc_test/4/39138/5268 +- sec61b_hipsc_test/4/39140/5293 +- sec61b_hipsc_test/4/39222/5281 +- sec61b_hipsc_test/4/39222/5311 +- sec61b_hipsc_test/4/39232/5329 +- sec61b_hipsc_test/4/39233/5304 +- sec61b_hipsc_test/4/39233/5313 +- sec61b_hipsc_test/4/39233/5327 +- sec61b_hipsc_test/4/39236/5305 +- sec61b_hipsc_test/4/40084/5357 +- sec61b_hipsc_test/4/40084/5415 +- sec61b_hipsc_test/4/40085/5421 +- sec61b_hipsc_test/4/40086/5362 +- sec61b_hipsc_test/4/40181/5434 +- sec61b_hipsc_test/4/40181/5451 +- sec61b_hipsc_test/4/40181/5453 +- sec61b_hipsc_test/4/40195/5479 +- sec61b_hipsc_test/4/40196/5471 +- sec61b_hipsc_test/4/40375/4612 +- sec61b_hipsc_test/4/40376/4568 +- sec61b_hipsc_test/4/40376/4601 +- sec61b_hipsc_test/4/40376/4604 +- sec61b_hipsc_test/4/40385/4565 +- sec61b_hipsc_test/4/40385/4572 +- sec61b_hipsc_test/4/40385/4576 +- sec61b_hipsc_test/4/40385/4610 +- sec61b_hipsc_test/4/40386/4603 +- sec61b_hipsc_test/4/40386/4606 +- sec61b_hipsc_test/4/40387/4570 +- sec61b_hipsc_test/4/40388/4591 +- sec61b_hipsc_test/4/40468/4624 +- sec61b_hipsc_test/4/40471/4659 +- sec61b_hipsc_test/4/40471/4661 +- sec61b_hipsc_test/4/40471/4679 +- sec61b_hipsc_test/4/40481/4627 +- sec61b_hipsc_test/4/40483/4621 +- sec61b_hipsc_test/4/40483/4637 +- sec61b_hipsc_test/4/40483/4644 +- sec61b_hipsc_test/4/40960/4630 +- sec61b_hipsc_test/4/40961/4665 +- sec61b_hipsc_test/4/40964/4643 +- sec61b_hipsc_test/4/41044/4869 +- sec61b_hipsc_test/4/41044/4891 +- sec61b_hipsc_test/4/41046/4849 +- sec61b_hipsc_test/4/41047/4885 +- sec61b_hipsc_test/4/41057/4887 +- sec61b_hipsc_test/4/41059/4886 +- sec61b_hipsc_test/4/41060/4901 +- sec61b_hipsc_test/4/41238/4828 +- sec61b_hipsc_test/4/41239/4823 +- sec61b_hipsc_test/4/41239/4832 +- sec61b_hipsc_test/4/41240/4818 +- sec61b_hipsc_test/4/41240/4834 +- sec61b_hipsc_test/4/41335/4803 +- sec61b_hipsc_test/4/41348/4809 +- sec61b_hipsc_test/4/41428/4713 +- sec61b_hipsc_test/4/41428/4718 +- sec61b_hipsc_test/4/41428/4743 +- sec61b_hipsc_test/4/41430/4744 +- sec61b_hipsc_test/4/41432/4729 +- sec61b_hipsc_test/4/41441/4725 +- sec61b_hipsc_test/4/41908/5037 +- sec61b_hipsc_test/4/41908/5061 +- sec61b_hipsc_test/4/41909/5071 +- sec61b_hipsc_test/4/41910/5031 +- sec61b_hipsc_test/4/41910/5058 +- sec61b_hipsc_test/4/41910/5088 +- sec61b_hipsc_test/4/41911/5027 +- sec61b_hipsc_test/4/42199/5048 +- sec61b_hipsc_test/4/42211/5034 +- sec61b_hipsc_test/42/136118/14223 +- sec61b_hipsc_test/42/136118/14225 +- sec61b_hipsc_test/42/136118/16503 +- sec61b_hipsc_test/42/136119/16504 +- sec61b_hipsc_test/42/136120/14221 +- sec61b_hipsc_test/42/136120/14224 +- sec61b_hipsc_test/42/136120/14228 +- sec61b_hipsc_test/42/136120/15747 +- sec61b_hipsc_test/42/136124/16127 +- sec61b_hipsc_test/42/138024/17222 +- sec61b_hipsc_test/42/138026/17232 +- sec61b_hipsc_test/42/138028/15839 +- sec61b_hipsc_test/42/138028/17202 +- sec61b_hipsc_test/42/138032/15577 +- sec61b_hipsc_test/42/138044/15777 +- sec61b_hipsc_test/42/138045/16692 +- sec61b_hipsc_test/42/138251/17249 +- sec61b_hipsc_test/42/138253/15966 +- sec61b_a549_mantis_2024_11_07_test/B/1/000000 +- sec61b_a549_mantis_2024_11_07_test/B/1/000001 +- sec61b_a549_mantis_2024_11_07_test/B/3/000000 +- sec61b_a549_mantis_2024_11_07_test/B/3/000001 +- sec61b_a549_mantis_2025_07_24_test/A/1/000000 +- sec61b_a549_mantis_2025_07_24_test/A/1/000001 +- sec61b_a549_mantis_2025_07_24_test/A/1/001000 +- sec61b_a549_mantis_2025_07_24_test/A/1/001001 +- sec61b_a549_mantis_2025_08_26_test/A/1/000000 +- sec61b_a549_mantis_2025_08_26_test/A/1/000001 +- sec61b_a549_mantis_2025_08_26_test/A/1/000002 +- sec61b_a549_mantis_2025_08_26_test/A/1/001000 diff --git a/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/tomm20_joint_all_v1.yaml b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/tomm20_joint_all_v1.yaml new file mode 100644 index 000000000..b03669241 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/tomm20_joint_all_v1.yaml @@ -0,0 +1,911 @@ +name: tomm20_joint_all_v1 +description: Joint frozen benchmark collection for target 'tomm20' across 6 source + datasets. Channels and FOV membership captured from the live train/test zarr stores + at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-24T19:29:30.139703+00:00' + created_by: Alex Kalinin +experiments: +- name: tomm20_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/TOMM20.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: tomm20_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/TOMM20.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_10_29_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_10_29_A549_TOMM20_ZIKV_DENV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_11_05_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_05_A549_TOMM20_ZIKV_DENV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_11_05_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_05_A549_TOMM20_ZIKV_DENV/test/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_11_21_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_21_A549_TOMM20_DENV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_11_21_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_21_A549_TOMM20_DENV/test/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2025_07_24_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2025_07_24_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV/test/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2025_08_26_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_08_26_A549_SEC61_TOMM20_ZIKV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2025_08_26_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_08_26_A549_SEC61_TOMM20_ZIKV/test/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +train_fovs: +- tomm20_hipsc_train/4/10614/1356 +- tomm20_hipsc_train/4/10624/1295 +- tomm20_hipsc_train/4/10624/1300 +- tomm20_hipsc_train/4/10624/1321 +- tomm20_hipsc_train/4/10625/1325 +- tomm20_hipsc_train/4/10625/1335 +- tomm20_hipsc_train/4/10900/1369 +- tomm20_hipsc_train/4/10900/1438 +- tomm20_hipsc_train/4/10901/1379 +- tomm20_hipsc_train/4/10901/1382 +- tomm20_hipsc_train/4/10903/1364 +- tomm20_hipsc_train/4/10903/1425 +- tomm20_hipsc_train/4/10904/1420 +- tomm20_hipsc_train/4/10904/1436 +- tomm20_hipsc_train/4/10915/1446 +- tomm20_hipsc_train/4/11380/1447 +- tomm20_hipsc_train/4/11396/1426 +- tomm20_hipsc_train/4/11396/1435 +- tomm20_hipsc_train/4/11396/1440 +- tomm20_hipsc_train/4/11478/1465 +- tomm20_hipsc_train/4/11488/1455 +- tomm20_hipsc_train/4/11489/1464 +- tomm20_hipsc_train/4/11489/1477 +- tomm20_hipsc_train/4/11490/1491 +- tomm20_hipsc_train/4/11492/1467 +- tomm20_hipsc_train/4/11572/1387 +- tomm20_hipsc_train/4/11572/1413 +- tomm20_hipsc_train/4/11573/1389 +- tomm20_hipsc_train/4/11574/1391 +- tomm20_hipsc_train/4/11575/1411 +- tomm20_hipsc_train/4/11575/1421 +- tomm20_hipsc_train/4/11669/1643 +- tomm20_hipsc_train/4/11670/1513 +- tomm20_hipsc_train/4/11672/1610 +- tomm20_hipsc_train/4/11681/1655 +- tomm20_hipsc_train/4/11682/1514 +- tomm20_hipsc_train/4/11682/1515 +- tomm20_hipsc_train/4/11682/1653 +- tomm20_hipsc_train/4/11683/1676 +- tomm20_hipsc_train/4/11684/1498 +- tomm20_hipsc_train/4/136707/16640 +- tomm20_hipsc_train/4/136707/16795 +- tomm20_hipsc_train/4/136708/16427 +- tomm20_hipsc_train/4/136710/15363 +- tomm20_hipsc_train/4/136710/15740 +- tomm20_hipsc_train/4/136710/16002 +- tomm20_hipsc_train/4/136710/16572 +- tomm20_hipsc_train/4/136712/15798 +- tomm20_hipsc_train/4/136712/17080 +- tomm20_hipsc_train/4/136712/17179 +- tomm20_hipsc_train/4/136714/15190 +- tomm20_hipsc_train/4/136717/16904 +- tomm20_hipsc_train/4/136719/15840 +- tomm20_hipsc_train/4/136719/16707 +- tomm20_hipsc_train/4/136721/15487 +- tomm20_hipsc_train/4/136721/15588 +- tomm20_hipsc_train/4/136721/15624 +- tomm20_hipsc_train/4/136721/16107 +- tomm20_hipsc_train/4/136723/16663 +- tomm20_hipsc_train/4/136723/16687 +- tomm20_hipsc_train/4/136723/16763 +- tomm20_hipsc_train/4/136725/16272 +- tomm20_hipsc_train/4/136736/15292 +- tomm20_hipsc_train/4/136736/16364 +- tomm20_hipsc_train/4/136738/14381 +- tomm20_hipsc_train/4/136738/16770 +- tomm20_hipsc_train/4/22132/2808 +- tomm20_hipsc_train/4/22132/2820 +- tomm20_hipsc_train/4/22133/2782 +- tomm20_hipsc_train/4/22133/2830 +- tomm20_hipsc_train/4/22134/2802 +- tomm20_hipsc_train/4/22135/2819 +- tomm20_hipsc_train/4/22135/2821 +- tomm20_hipsc_train/4/22325/3154 +- tomm20_hipsc_train/4/22326/3079 +- tomm20_hipsc_train/4/22326/3121 +- tomm20_hipsc_train/4/22326/3139 +- tomm20_hipsc_train/4/22327/3081 +- tomm20_hipsc_train/4/22327/3087 +- tomm20_hipsc_train/4/22327/3117 +- tomm20_hipsc_train/4/22327/3120 +- tomm20_hipsc_train/4/22327/3126 +- tomm20_hipsc_train/4/22327/3144 +- tomm20_hipsc_train/4/22327/3153 +- tomm20_hipsc_train/4/22328/3077 +- tomm20_hipsc_train/4/22328/3099 +- tomm20_hipsc_train/4/22328/3125 +- tomm20_hipsc_train/4/22328/3135 +- tomm20_hipsc_train/4/22339/3095 +- tomm20_hipsc_train/4/22339/3105 +- tomm20_hipsc_train/4/22339/3116 +- tomm20_hipsc_train/4/22339/3129 +- tomm20_hipsc_train/4/22339/3150 +- tomm20_hipsc_train/4/22340/3071 +- tomm20_hipsc_train/4/22612/2918 +- tomm20_hipsc_train/4/22612/2992 +- tomm20_hipsc_train/4/22613/2897 +- tomm20_hipsc_train/4/22614/2972 +- tomm20_hipsc_train/4/22615/2913 +- tomm20_hipsc_train/4/22615/2970 +- tomm20_hipsc_train/4/22624/2899 +- tomm20_hipsc_train/4/22624/2911 +- tomm20_hipsc_train/4/22624/2920 +- tomm20_hipsc_train/4/22625/2914 +- tomm20_hipsc_train/4/22709/3112 +- tomm20_hipsc_train/4/22711/3072 +- tomm20_hipsc_train/4/22720/3100 +- tomm20_hipsc_train/4/22720/3110 +- tomm20_hipsc_train/4/22721/3062 +- tomm20_hipsc_train/4/22721/3067 +- tomm20_hipsc_train/4/22900/3316 +- tomm20_hipsc_train/4/22901/3283 +- tomm20_hipsc_train/4/22901/3285 +- tomm20_hipsc_train/4/22902/3279 +- tomm20_hipsc_train/4/22915/3292 +- tomm20_hipsc_train/4/22916/3312 +- tomm20_hipsc_train/4/23284/3464 +- tomm20_hipsc_train/4/23284/3468 +- tomm20_hipsc_train/4/23284/3487 +- tomm20_hipsc_train/4/23284/3499 +- tomm20_hipsc_train/4/23285/3466 +- tomm20_hipsc_train/4/23285/3509 +- tomm20_hipsc_train/4/23286/3454 +- tomm20_hipsc_train/4/23286/3515 +- tomm20_hipsc_train/4/23287/3465 +- tomm20_hipsc_train/4/23287/3484 +- tomm20_hipsc_train/4/23383/3173 +- tomm20_hipsc_train/4/23383/3255 +- tomm20_hipsc_train/4/23384/3187 +- tomm20_hipsc_train/4/23384/3201 +- tomm20_hipsc_train/4/23392/3239 +- tomm20_hipsc_train/4/23393/3259 +- tomm20_hipsc_train/4/23394/3192 +- tomm20_hipsc_train/4/23394/3251 +- tomm20_hipsc_train/4/23476/3329 +- tomm20_hipsc_train/4/23478/3324 +- tomm20_hipsc_train/4/23478/3328 +- tomm20_hipsc_train/4/23478/3363 +- tomm20_hipsc_train/4/23479/3347 +- tomm20_hipsc_train/4/23572/3536 +- tomm20_hipsc_train/4/23573/3513 +- tomm20_hipsc_train/4/23573/3519 +- tomm20_hipsc_train/4/23573/3527 +- tomm20_hipsc_train/4/23573/3538 +- tomm20_hipsc_train/4/23574/3492 +- tomm20_hipsc_train/4/23574/3504 +- tomm20_hipsc_train/4/23585/3498 +- tomm20_hipsc_train/4/23764/3403 +- tomm20_hipsc_train/4/23766/3411 +- tomm20_hipsc_train/4/23767/3421 +- tomm20_hipsc_train/4/23767/3425 +- tomm20_hipsc_train/4/23778/3408 +- tomm20_hipsc_train/4/24148/3551 +- tomm20_hipsc_train/4/24148/3554 +- tomm20_hipsc_train/4/24148/3572 +- tomm20_hipsc_train/4/24149/3555 +- tomm20_hipsc_train/4/24149/3568 +- tomm20_hipsc_train/4/24150/3550 +- tomm20_hipsc_train/4/24150/3562 +- tomm20_hipsc_train/4/24151/3508 +- tomm20_hipsc_train/4/24151/3532 +- tomm20_hipsc_train/4/24151/3547 +- tomm20_hipsc_train/4/24151/3563 +- tomm20_hipsc_train/4/24152/3526 +- tomm20_hipsc_train/4/24152/3545 +- tomm20_hipsc_train/4/24152/3573 +- tomm20_hipsc_train/4/24160/3478 +- tomm20_hipsc_train/4/24160/3564 +- tomm20_hipsc_train/4/24724/3641 +- tomm20_hipsc_train/4/24724/3661 +- tomm20_hipsc_train/4/24724/3688 +- tomm20_hipsc_train/4/24727/3648 +- tomm20_hipsc_train/4/24727/3651 +- tomm20_hipsc_train/4/24727/3659 +- tomm20_hipsc_train/4/24727/3660 +- tomm20_hipsc_train/4/24728/3655 +- tomm20_hipsc_train/4/24728/3678 +- tomm20_hipsc_train/4/24739/3638 +- tomm20_hipsc_train/4/24739/3644 +- tomm20_hipsc_train/4/24739/3647 +- tomm20_hipsc_train/4/24739/3681 +- tomm20_hipsc_train/4/24739/3683 +- tomm20_hipsc_train/4/24739/3703 +- tomm20_hipsc_train/4/24740/3657 +- tomm20_hipsc_train/4/24740/3701 +- tomm20_hipsc_train/4/24820/14 +- tomm20_hipsc_train/4/24820/15 +- tomm20_hipsc_train/4/24820/18 +- tomm20_hipsc_train/4/24820/3 +- tomm20_hipsc_train/4/24821/11 +- tomm20_hipsc_train/4/24822/1 +- tomm20_hipsc_train/4/24833/2 +- tomm20_hipsc_train/4/24833/27 +- tomm20_hipsc_train/4/24834/23 +- tomm20_hipsc_train/4/24928/3614 +- tomm20_hipsc_train/4/24929/3580 +- tomm20_hipsc_train/4/24929/3600 +- tomm20_hipsc_train/4/24929/3603 +- tomm20_hipsc_train/4/24929/3608 +- tomm20_hipsc_train/4/24930/3583 +- tomm20_hipsc_train/4/24930/3617 +- tomm20_hipsc_train/4/24931/3581 +- tomm20_hipsc_train/4/24931/3606 +- tomm20_hipsc_train/4/24932/3598 +- tomm20_hipsc_train/4/25204/3792 +- tomm20_hipsc_train/4/25205/3812 +- tomm20_hipsc_train/4/25206/3806 +- tomm20_hipsc_train/4/25208/3798 +- tomm20_hipsc_train/4/25208/3815 +- tomm20_hipsc_train/4/25208/3821 +- tomm20_hipsc_train/4/25216/3794 +- tomm20_hipsc_train/4/25781/3833 +- tomm20_hipsc_train/4/25781/3843 +- tomm20_hipsc_train/4/25781/3854 +- tomm20_hipsc_train/4/25781/3858 +- tomm20_hipsc_train/4/25782/3855 +- tomm20_hipsc_train/4/25783/3849 +- tomm20_hipsc_train/4/25783/3857 +- tomm20_hipsc_train/4/25784/3852 +- tomm20_hipsc_train/4/27798/2892 +- tomm20_hipsc_train/4/27799/2871 +- tomm20_hipsc_train/4/27799/2884 +- tomm20_hipsc_train/4/27800/2875 +- tomm20_hipsc_train/4/27808/2862 +- tomm20_hipsc_train/4/27808/2876 +- tomm20_hipsc_train/4/27809/2886 +- tomm20_hipsc_train/4/27892/2930 +- tomm20_hipsc_train/4/27893/2938 +- tomm20_hipsc_train/4/27893/2950 +- tomm20_hipsc_train/4/27894/2945 +- tomm20_hipsc_train/4/27896/2943 +- tomm20_hipsc_train/4/27904/2979 +- tomm20_hipsc_train/4/27906/2983 +- tomm20_hipsc_train/4/27988/3025 +- tomm20_hipsc_train/4/27990/3026 +- tomm20_hipsc_train/4/27992/3014 +- tomm20_hipsc_train/4/28000/3038 +- tomm20_hipsc_train/4/28001/3005 +- tomm20_hipsc_train/4/28001/3027 +- tomm20_hipsc_train/4/28001/3031 +- tomm20_hipsc_train/4/28002/3007 +- tomm20_hipsc_train/4/28002/3022 +- tomm20_hipsc_train/4/28002/3036 +- tomm20_hipsc_train/4/28084/3232 +- tomm20_hipsc_train/4/28084/3254 +- tomm20_hipsc_train/4/28085/3213 +- tomm20_hipsc_train/4/28085/3258 +- tomm20_hipsc_train/4/28086/3211 +- tomm20_hipsc_train/4/28086/3236 +- tomm20_hipsc_train/4/28087/3240 +- tomm20_hipsc_train/4/28087/3242 +- tomm20_hipsc_train/4/28087/3266 +- tomm20_hipsc_train/4/28088/3205 +- tomm20_hipsc_train/4/28088/3238 +- tomm20_hipsc_train/4/28088/3268 +- tomm20_hipsc_train/4/28756/3366 +- tomm20_hipsc_train/4/28758/3397 +- tomm20_hipsc_train/4/28759/3399 +- tomm20_hipsc_train/4/28760/3388 +- tomm20_hipsc_train/4/28760/3402 +- tomm20_hipsc_train/4/28769/3372 +- tomm20_hipsc_train/4/28770/3377 +- tomm20_hipsc_train/4/29045/3774 +- tomm20_hipsc_train/4/29045/3779 +- tomm20_hipsc_train/4/29045/3782 +- tomm20_hipsc_train/4/29046/3750 +- tomm20_hipsc_train/4/29046/3762 +- tomm20_hipsc_train/4/29047/3766 +- tomm20_hipsc_train/4/29058/3772 +- tomm20_hipsc_train/4/29059/3758 +- tomm20_hipsc_train/4/29059/3765 +- tomm20_hipsc_train/4/29060/3753 +- tomm20_hipsc_train/4/29140/3684 +- tomm20_hipsc_train/4/29140/3716 +- tomm20_hipsc_train/4/29140/3726 +- tomm20_hipsc_train/4/29141/3709 +- tomm20_hipsc_train/4/29141/3719 +- tomm20_hipsc_train/4/29141/3728 +- tomm20_hipsc_train/4/29141/3742 +- tomm20_hipsc_train/4/29142/3695 +- tomm20_hipsc_train/4/29142/3739 +- tomm20_hipsc_train/4/29143/3680 +- tomm20_hipsc_train/4/29152/3708 +- tomm20_hipsc_train/4/29152/3712 +- tomm20_hipsc_train/4/29152/3723 +- tomm20_hipsc_train/4/29153/3725 +- tomm20_hipsc_train/4/29155/3689 +- tomm20_hipsc_train/4/29155/3714 +- tomm20_hipsc_train/4/29332/3865 +- tomm20_hipsc_train/4/29333/3868 +- tomm20_hipsc_train/4/29333/3908 +- tomm20_hipsc_train/4/29334/3889 +- tomm20_hipsc_train/4/29334/3890 +- tomm20_hipsc_train/4/29334/3892 +- tomm20_hipsc_train/4/29335/3867 +- tomm20_hipsc_train/4/29335/3879 +- tomm20_hipsc_train/4/29335/3900 +- tomm20_hipsc_train/4/30292/3893 +- tomm20_hipsc_train/4/30292/3913 +- tomm20_hipsc_train/4/30293/3905 +- tomm20_hipsc_train/4/30294/15038 +- tomm20_hipsc_train/4/30294/16432 +- tomm20_hipsc_train/4/30294/3906 +- tomm20_hipsc_train/4/30294/3912 +- tomm20_hipsc_train/4/30304/3866 +- tomm20_hipsc_train/4/30308/3869 +- tomm20_hipsc_train/4/30308/3871 +- tomm20_hipsc_train/4/30389/16772 +- tomm20_hipsc_train/4/30392/16282 +- tomm20_hipsc_train/4/30677/15449 +- tomm20_hipsc_train/4/30677/16684 +- tomm20_hipsc_train/4/30677/16969 +- tomm20_hipsc_train/4/30679/15295 +- tomm20_hipsc_train/4/30679/15878 +- tomm20_hipsc_train/4/30680/17051 +- tomm20_hipsc_train/4/30688/15165 +- tomm20_hipsc_train/4/30689/15310 +- tomm20_hipsc_train/4/5140/925 +- tomm20_hipsc_train/4/5140/933 +- tomm20_hipsc_train/4/5140/950 +- tomm20_hipsc_train/4/5141/928 +- tomm20_hipsc_train/4/5141/940 +- tomm20_hipsc_train/4/5143/954 +- tomm20_hipsc_train/4/5144/943 +- tomm20_hipsc_train/4/5236/869 +- tomm20_hipsc_train/4/5236/913 +- tomm20_hipsc_train/4/5237/858 +- tomm20_hipsc_train/4/5238/1043 +- tomm20_hipsc_train/4/5238/815 +- tomm20_hipsc_train/4/5238/867 +- tomm20_hipsc_train/4/5238/873 +- tomm20_hipsc_train/4/5238/938 +- tomm20_hipsc_train/4/5239/888 +- tomm20_hipsc_train/4/5248/1038 +- tomm20_hipsc_train/4/5248/910 +- tomm20_hipsc_train/4/5250/902 +- tomm20_hipsc_train/4/5910/824 +- tomm20_hipsc_train/4/5912/841 +- tomm20_hipsc_train/4/5920/843 +- tomm20_hipsc_train/4/5921/828 +- tomm20_hipsc_train/4/5923/837 +- tomm20_hipsc_train/4/5923/853 +- tomm20_hipsc_train/4/5923/855 +- tomm20_hipsc_train/4/5924/819 +- tomm20_hipsc_train/4/6485/1007 +- tomm20_hipsc_train/4/6485/1011 +- tomm20_hipsc_train/4/6485/978 +- tomm20_hipsc_train/4/6485/980 +- tomm20_hipsc_train/4/6485/997 +- tomm20_hipsc_train/4/6486/1002 +- tomm20_hipsc_train/4/6486/1006 +- tomm20_hipsc_train/4/6486/1012 +- tomm20_hipsc_train/4/6486/1022 +- tomm20_hipsc_train/4/6486/965 +- tomm20_hipsc_train/4/6486/968 +- tomm20_hipsc_train/4/6486/981 +- tomm20_hipsc_train/4/6487/1015 +- tomm20_hipsc_train/4/6487/1020 +- tomm20_hipsc_train/4/6487/993 +- tomm20_hipsc_train/4/6497/1014 +- tomm20_hipsc_train/4/6497/1017 +- tomm20_hipsc_train/4/6497/1025 +- tomm20_hipsc_train/4/6497/976 +- tomm20_hipsc_train/4/6774/1134 +- tomm20_hipsc_train/4/6774/1218 +- tomm20_hipsc_train/4/6775/1100 +- tomm20_hipsc_train/4/6775/1176 +- tomm20_hipsc_train/4/6775/1187 +- tomm20_hipsc_train/4/6775/1191 +- tomm20_hipsc_train/4/6775/1193 +- tomm20_hipsc_train/4/6775/1195 +- tomm20_hipsc_train/4/6775/1228 +- tomm20_hipsc_train/4/6775/1232 +- tomm20_hipsc_train/4/6775/1236 +- tomm20_hipsc_train/4/6775/1240 +- tomm20_hipsc_train/4/6775/1248 +- tomm20_hipsc_train/4/6776/1153 +- tomm20_hipsc_train/4/6776/1185 +- tomm20_hipsc_train/4/6776/1199 +- tomm20_hipsc_train/4/7156/1104 +- tomm20_hipsc_train/4/7157/1102 +- tomm20_hipsc_train/4/7158/1105 +- tomm20_hipsc_train/4/7158/1119 +- tomm20_hipsc_train/4/7158/1123 +- tomm20_hipsc_train/4/7348/1326 +- tomm20_hipsc_train/4/7349/1348 +- tomm20_hipsc_train/4/7349/1352 +- tomm20_hipsc_train/4/7636/1269 +- tomm20_hipsc_train/4/7636/1272 +- tomm20_hipsc_train/4/7636/1287 +- tomm20_hipsc_train/4/7637/1270 +- tomm20_hipsc_train/4/7637/1293 +- tomm20_hipsc_train/4/7638/1279 +- tomm20_hipsc_train/4/7650/1252 +- tomm20_hipsc_train/4/7650/1278 +- tomm20_hipsc_train/4/7650/1288 +- tomm20_hipsc_train/4/8214/897 +- tomm20_hipsc_train/4/8214/903 +- tomm20_hipsc_train/4/8214/907 +- tomm20_hipsc_train/4/8225/899 +- tomm20_hipsc_train/4/8225/904 +- tomm20_hipsc_train/4/8309/1032 +- tomm20_hipsc_train/4/8310/1091 +- tomm20_hipsc_train/4/8311/1074 +- tomm20_hipsc_train/4/8692/1096 +- tomm20_hipsc_train/4/8692/1114 +- tomm20_hipsc_train/4/8692/1227 +- tomm20_hipsc_train/4/8695/1082 +- tomm20_hipsc_train/4/8695/1198 +- tomm20_hipsc_train/4/8695/1211 +- tomm20_hipsc_train/4/8695/1215 +- tomm20_hipsc_train/4/8696/1079 +- tomm20_hipsc_train/4/8705/1221 +- tomm20_hipsc_train/4/8706/1072 +- tomm20_hipsc_train/4/8707/1219 +- tomm20_hipsc_train/4/8708/1127 +- tomm20_hipsc_train/4/8708/1173 +- tomm20_hipsc_train/4/8708/1213 +- tomm20_hipsc_train/4/8708/1233 +- tomm20_hipsc_train/4/8980/1167 +- tomm20_hipsc_train/4/8980/1168 +- tomm20_hipsc_train/4/8980/1175 +- tomm20_hipsc_train/4/8980/1181 +- tomm20_hipsc_train/4/8981/1143 +- tomm20_hipsc_train/4/8981/1155 +- tomm20_hipsc_train/4/8982/1150 +- tomm20_hipsc_train/4/8982/1163 +- tomm20_hipsc_train/4/9748/15080 +- tomm20_hipsc_train/4/9748/15365 +- tomm20_hipsc_train/4/9748/15563 +- tomm20_hipsc_train/4/9748/15711 +- tomm20_hipsc_train/4/9748/15871 +- tomm20_hipsc_train/4/9748/16327 +- tomm20_hipsc_train/4/9748/16440 +- tomm20_hipsc_train/4/9748/16524 +- tomm20_hipsc_train/4/9748/16929 +- tomm20_hipsc_train/4/9748/17154 +- tomm20_hipsc_train/42/135521/14270 +- tomm20_hipsc_train/42/135523/14265 +- tomm20_hipsc_train/42/135524/14251 +- tomm20_hipsc_train/42/135525/14254 +- tomm20_hipsc_train/42/135525/15339 +- tomm20_hipsc_train/42/135526/14250 +- tomm20_hipsc_train/42/135526/14256 +- tomm20_hipsc_train/42/135526/14257 +- tomm20_hipsc_train/42/135614/14199 +- tomm20_hipsc_train/42/135614/14210 +- tomm20_hipsc_train/42/135615/14176 +- tomm20_hipsc_train/42/135615/14194 +- tomm20_hipsc_train/42/135615/14209 +- tomm20_hipsc_train/42/135616/14159 +- tomm20_hipsc_train/42/135616/14160 +- tomm20_hipsc_train/42/135616/14180 +- tomm20_hipsc_train/42/135616/14191 +- tomm20_hipsc_train/42/135617/14162 +- tomm20_hipsc_train/42/135617/14200 +- tomm20_hipsc_train/42/135617/14213 +- tomm20_hipsc_train/42/135617/14218 +- tomm20_hipsc_train/42/135618/14161 +- tomm20_hipsc_train/42/135618/14170 +- tomm20_hipsc_train/42/135618/14177 +- tomm20_hipsc_train/42/135618/14203 +- tomm20_hipsc_train/42/135619/14174 +- tomm20_hipsc_train/42/135619/14208 +- tomm20_hipsc_train/42/135620/14192 +- tomm20_hipsc_train/42/135620/14202 +- tomm20_hipsc_train/42/135622/14167 +- tomm20_hipsc_train/42/135622/14181 +- tomm20_hipsc_train/42/135622/14197 +- tomm20_hipsc_train/42/135622/14217 +- tomm20_hipsc_train/42/136130/14294 +- tomm20_hipsc_train/42/136130/14297 +- tomm20_hipsc_train/42/136130/14305 +- tomm20_hipsc_train/42/136131/14307 +- tomm20_hipsc_train/42/136131/14315 +- tomm20_hipsc_train/42/136131/14319 +- tomm20_hipsc_train/42/136131/14335 +- tomm20_hipsc_train/42/136132/14322 +- tomm20_hipsc_train/42/136132/14326 +- tomm20_hipsc_train/42/136132/14332 +- tomm20_hipsc_train/42/136133/14283 +- tomm20_hipsc_train/42/136133/14285 +- tomm20_hipsc_train/42/136134/14291 +- tomm20_hipsc_train/42/136134/14328 +- tomm20_hipsc_train/42/136135/14316 +- tomm20_hipsc_train/42/136135/14321 +- tomm20_hipsc_train/42/136136/14279 +- tomm20_hipsc_train/42/137952/15541 +- tomm20_hipsc_train/42/137952/16945 +- tomm20_hipsc_train/42/137952/17148 +- tomm20_hipsc_train/42/137953/16951 +- tomm20_hipsc_train/42/137954/15782 +- tomm20_hipsc_train/42/137954/16856 +- tomm20_hipsc_train/42/137954/16893 +- tomm20_hipsc_train/42/137955/15694 +- tomm20_hipsc_train/42/137955/15892 +- tomm20_hipsc_train/42/137955/16043 +- tomm20_hipsc_train/42/137956/16613 +- tomm20_hipsc_train/42/137956/17196 +- tomm20_hipsc_train/42/137956/17233 +- tomm20_a549_mantis_2024_10_29_train/B/4/000000 +- tomm20_a549_mantis_2024_10_29_train/B/4/000001 +- tomm20_a549_mantis_2024_10_29_train/B/4/001000 +- tomm20_a549_mantis_2024_10_29_train/B/4/001001 +- tomm20_a549_mantis_2024_10_29_train/B/4/002001 +- tomm20_a549_mantis_2024_10_29_train/C/4/000000 +- tomm20_a549_mantis_2024_10_29_train/C/4/000001 +- tomm20_a549_mantis_2024_10_29_train/C/4/001000 +- tomm20_a549_mantis_2024_10_29_train/C/4/002000 +- tomm20_a549_mantis_2024_10_29_train/C/4/002001 +- tomm20_a549_mantis_2024_11_05_train/B/4/001001 +- tomm20_a549_mantis_2024_11_05_train/B/4/002000 +- tomm20_a549_mantis_2024_11_05_train/B/4/002001 +- tomm20_a549_mantis_2024_11_21_train/B/1/001001 +- tomm20_a549_mantis_2024_11_21_train/B/3/000000 +- tomm20_a549_mantis_2024_11_21_train/B/3/000001 +- tomm20_a549_mantis_2024_11_21_train/B/3/001000 +- tomm20_a549_mantis_2024_11_21_train/B/3/001001 +- tomm20_a549_mantis_2025_07_24_train/B/1/001001 +- tomm20_a549_mantis_2025_07_24_train/B/1/002000 +- tomm20_a549_mantis_2025_07_24_train/B/1/002001 +- tomm20_a549_mantis_2025_08_26_train/A/2/001000 +- tomm20_a549_mantis_2025_08_26_train/A/2/001001 +- tomm20_a549_mantis_2025_08_26_train/A/2/001002 +- tomm20_a549_mantis_2025_08_26_train/A/2/002000 +- tomm20_a549_mantis_2025_08_26_train/A/2/002001 +- tomm20_a549_mantis_2025_08_26_train/A/2/002002 +- tomm20_a549_mantis_2025_08_26_train/B/2/002000 +- tomm20_a549_mantis_2025_08_26_train/B/2/002001 +- tomm20_a549_mantis_2025_08_26_train/B/2/002002 +test_fovs: +- tomm20_hipsc_test/4/10612/1362 +- tomm20_hipsc_test/4/10624/1349 +- tomm20_hipsc_test/4/11380/1459 +- tomm20_hipsc_test/4/11380/1471 +- tomm20_hipsc_test/4/11384/1404 +- tomm20_hipsc_test/4/11476/16725 +- tomm20_hipsc_test/4/11477/1493 +- tomm20_hipsc_test/4/11492/1472 +- tomm20_hipsc_test/4/11575/1394 +- tomm20_hipsc_test/4/11670/1462 +- tomm20_hipsc_test/4/11680/1686 +- tomm20_hipsc_test/4/11682/1660 +- tomm20_hipsc_test/4/136707/16604 +- tomm20_hipsc_test/4/22132/2823 +- tomm20_hipsc_test/4/22133/2798 +- tomm20_hipsc_test/4/22135/2792 +- tomm20_hipsc_test/4/22135/2822 +- tomm20_hipsc_test/4/22325/3131 +- tomm20_hipsc_test/4/22326/3141 +- tomm20_hipsc_test/4/22327/3137 +- tomm20_hipsc_test/4/22340/3097 +- tomm20_hipsc_test/4/22612/2958 +- tomm20_hipsc_test/4/22612/2986 +- tomm20_hipsc_test/4/23285/3452 +- tomm20_hipsc_test/4/23286/3512 +- tomm20_hipsc_test/4/23381/3195 +- tomm20_hipsc_test/4/23382/3245 +- tomm20_hipsc_test/4/23384/3170 +- tomm20_hipsc_test/4/23384/3253 +- tomm20_hipsc_test/4/23394/3196 +- tomm20_hipsc_test/4/23572/3529 +- tomm20_hipsc_test/4/23768/3424 +- tomm20_hipsc_test/4/23777/3418 +- tomm20_hipsc_test/4/24149/3481 +- tomm20_hipsc_test/4/24150/3537 +- tomm20_hipsc_test/4/24724/3645 +- tomm20_hipsc_test/4/24724/3649 +- tomm20_hipsc_test/4/24834/13 +- tomm20_hipsc_test/4/24930/3599 +- tomm20_hipsc_test/4/24931/3592 +- tomm20_hipsc_test/4/24932/3588 +- tomm20_hipsc_test/4/25207/3818 +- tomm20_hipsc_test/4/25207/3824 +- tomm20_hipsc_test/4/27798/2891 +- tomm20_hipsc_test/4/27892/2961 +- tomm20_hipsc_test/4/27990/3010 +- tomm20_hipsc_test/4/27990/3012 +- tomm20_hipsc_test/4/27991/3009 +- tomm20_hipsc_test/4/27991/3028 +- tomm20_hipsc_test/4/28001/3016 +- tomm20_hipsc_test/4/28084/3200 +- tomm20_hipsc_test/4/28084/3214 +- tomm20_hipsc_test/4/28086/3250 +- tomm20_hipsc_test/4/28087/3224 +- tomm20_hipsc_test/4/28756/3370 +- tomm20_hipsc_test/4/28760/3390 +- tomm20_hipsc_test/4/29142/3718 +- tomm20_hipsc_test/4/29142/3720 +- tomm20_hipsc_test/4/29143/3679 +- tomm20_hipsc_test/4/29152/3740 +- tomm20_hipsc_test/4/29332/3860 +- tomm20_hipsc_test/4/29336/3885 +- tomm20_hipsc_test/4/29336/3896 +- tomm20_hipsc_test/4/30292/3909 +- tomm20_hipsc_test/4/30294/3901 +- tomm20_hipsc_test/4/30391/15032 +- tomm20_hipsc_test/4/30679/3933 +- tomm20_hipsc_test/4/5141/926 +- tomm20_hipsc_test/4/5143/953 +- tomm20_hipsc_test/4/5240/1073 +- tomm20_hipsc_test/4/5912/823 +- tomm20_hipsc_test/4/6485/990 +- tomm20_hipsc_test/4/6486/989 +- tomm20_hipsc_test/4/6486/991 +- tomm20_hipsc_test/4/6497/1009 +- tomm20_hipsc_test/4/6776/1122 +- tomm20_hipsc_test/4/7349/1359 +- tomm20_hipsc_test/4/7638/1280 +- tomm20_hipsc_test/4/7639/1264 +- tomm20_hipsc_test/4/7650/1285 +- tomm20_hipsc_test/4/8228/886 +- tomm20_hipsc_test/4/8228/893 +- tomm20_hipsc_test/4/8228/906 +- tomm20_hipsc_test/4/8692/1235 +- tomm20_hipsc_test/4/8705/1209 +- tomm20_hipsc_test/4/8705/1225 +- tomm20_hipsc_test/4/8982/1147 +- tomm20_hipsc_test/4/9748/16392 +- tomm20_hipsc_test/4/9748/16574 +- tomm20_hipsc_test/4/9748/16977 +- tomm20_hipsc_test/4/9749/16734 +- tomm20_hipsc_test/42/135525/16168 +- tomm20_hipsc_test/42/135615/14189 +- tomm20_hipsc_test/42/135621/14220 +- tomm20_hipsc_test/42/136130/14325 +- tomm20_hipsc_test/42/136133/14302 +- tomm20_hipsc_test/42/136134/14300 +- tomm20_hipsc_test/42/136136/14317 +- tomm20_hipsc_test/42/136136/14320 +- tomm20_hipsc_test/42/137953/15532 +- tomm20_a549_mantis_2024_11_05_test/B/4/000000 +- tomm20_a549_mantis_2024_11_05_test/B/4/000001 +- tomm20_a549_mantis_2024_11_05_test/B/4/001000 +- tomm20_a549_mantis_2024_11_05_test/C/4/001000 +- tomm20_a549_mantis_2024_11_05_test/C/4/001001 +- tomm20_a549_mantis_2024_11_05_test/C/4/002000 +- tomm20_a549_mantis_2024_11_05_test/C/4/002001 +- tomm20_a549_mantis_2024_11_21_test/B/1/000000 +- tomm20_a549_mantis_2024_11_21_test/B/1/000001 +- tomm20_a549_mantis_2024_11_21_test/B/1/001000 +- tomm20_a549_mantis_2024_11_21_test/B/2/000000 +- tomm20_a549_mantis_2024_11_21_test/B/2/000001 +- tomm20_a549_mantis_2024_11_21_test/B/2/001000 +- tomm20_a549_mantis_2024_11_21_test/B/2/001001 +- tomm20_a549_mantis_2024_11_21_test/C/2/000000 +- tomm20_a549_mantis_2024_11_21_test/C/2/000001 +- tomm20_a549_mantis_2024_11_21_test/C/2/001000 +- tomm20_a549_mantis_2024_11_21_test/C/2/001001 +- tomm20_a549_mantis_2025_07_24_test/B/1/000000 +- tomm20_a549_mantis_2025_07_24_test/B/1/000001 +- tomm20_a549_mantis_2025_07_24_test/B/1/001000 +- tomm20_a549_mantis_2025_07_24_test/B/2/000000 +- tomm20_a549_mantis_2025_07_24_test/B/2/000001 +- tomm20_a549_mantis_2025_07_24_test/B/2/001000 +- tomm20_a549_mantis_2025_07_24_test/B/2/001001 +- tomm20_a549_mantis_2025_07_24_test/B/2/002000 +- tomm20_a549_mantis_2025_07_24_test/B/2/002001 +- tomm20_a549_mantis_2025_08_26_test/A/2/000000 +- tomm20_a549_mantis_2025_08_26_test/A/2/000001 +- tomm20_a549_mantis_2025_08_26_test/A/2/000002 +- tomm20_a549_mantis_2025_08_26_test/B/2/000000 +- tomm20_a549_mantis_2025_08_26_test/B/2/000001 +- tomm20_a549_mantis_2025_08_26_test/B/2/000002 +- tomm20_a549_mantis_2025_08_26_test/B/2/001000 +- tomm20_a549_mantis_2025_08_26_test/B/2/001001 +- tomm20_a549_mantis_2025_08_26_test/B/2/001002 diff --git a/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/tomm20_joint_mock_v1.yaml b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/tomm20_joint_mock_v1.yaml new file mode 100644 index 000000000..6af6bc8da --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/collections/virtual_staining/tomm20_joint_mock_v1.yaml @@ -0,0 +1,879 @@ +name: tomm20_joint_mock_v1 +description: Joint frozen benchmark collection for target 'tomm20' with condition + filter 'mock' across 6 source datasets. Channels and FOV membership captured from + the live train/test zarr stores at freeze time. +provenance: + airtable_base_id: null + airtable_query: null + record_ids: [] + created_at: '2026-04-24T19:47:52.169999+00:00' + created_by: Alex Kalinin +experiments: +- name: tomm20_hipsc_train + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/train/TOMM20.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: tomm20_hipsc_test + data_path: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/TOMM20.zarr + channels: + - name: Brightfield + marker: Brightfield + wells: [] + - name: Nuclei + marker: Nuclei + wells: [] + - name: Membrane + marker: Membrane + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + - name: Phase3D + marker: Phase3D + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.108 + pixel_size_z_um: 0.29 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_10_29_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_10_29_A549_TOMM20_ZIKV_DENV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_11_05_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_05_A549_TOMM20_ZIKV_DENV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_11_05_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_05_A549_TOMM20_ZIKV_DENV/test/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_11_21_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_21_A549_TOMM20_DENV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2024_11_21_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2024_11_21_A549_TOMM20_DENV/test/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2025_07_24_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2025_07_24_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV/test/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2025_08_26_train + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_08_26_A549_SEC61_TOMM20_ZIKV/train/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +- name: tomm20_a549_mantis_2025_08_26_test + data_path: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/2025_08_26_A549_SEC61_TOMM20_ZIKV/test/TOMM20.zarr + channels: + - name: Phase3D + marker: Phase3D + wells: [] + - name: Brightfield + marker: Brightfield + wells: [] + - name: Structure + marker: TOMM20 + wells: [] + perturbation_wells: null + interval_minutes: null + start_hpi: null + marker: TOMM20 + organelle: mitochondria + pixel_size_xy_um: 0.1494 + pixel_size_z_um: 0.174 + exclude_fovs: [] +train_fovs: +- tomm20_hipsc_train/4/10614/1356 +- tomm20_hipsc_train/4/10624/1295 +- tomm20_hipsc_train/4/10624/1300 +- tomm20_hipsc_train/4/10624/1321 +- tomm20_hipsc_train/4/10625/1325 +- tomm20_hipsc_train/4/10625/1335 +- tomm20_hipsc_train/4/10900/1369 +- tomm20_hipsc_train/4/10900/1438 +- tomm20_hipsc_train/4/10901/1379 +- tomm20_hipsc_train/4/10901/1382 +- tomm20_hipsc_train/4/10903/1364 +- tomm20_hipsc_train/4/10903/1425 +- tomm20_hipsc_train/4/10904/1420 +- tomm20_hipsc_train/4/10904/1436 +- tomm20_hipsc_train/4/10915/1446 +- tomm20_hipsc_train/4/11380/1447 +- tomm20_hipsc_train/4/11396/1426 +- tomm20_hipsc_train/4/11396/1435 +- tomm20_hipsc_train/4/11396/1440 +- tomm20_hipsc_train/4/11478/1465 +- tomm20_hipsc_train/4/11488/1455 +- tomm20_hipsc_train/4/11489/1464 +- tomm20_hipsc_train/4/11489/1477 +- tomm20_hipsc_train/4/11490/1491 +- tomm20_hipsc_train/4/11492/1467 +- tomm20_hipsc_train/4/11572/1387 +- tomm20_hipsc_train/4/11572/1413 +- tomm20_hipsc_train/4/11573/1389 +- tomm20_hipsc_train/4/11574/1391 +- tomm20_hipsc_train/4/11575/1411 +- tomm20_hipsc_train/4/11575/1421 +- tomm20_hipsc_train/4/11669/1643 +- tomm20_hipsc_train/4/11670/1513 +- tomm20_hipsc_train/4/11672/1610 +- tomm20_hipsc_train/4/11681/1655 +- tomm20_hipsc_train/4/11682/1514 +- tomm20_hipsc_train/4/11682/1515 +- tomm20_hipsc_train/4/11682/1653 +- tomm20_hipsc_train/4/11683/1676 +- tomm20_hipsc_train/4/11684/1498 +- tomm20_hipsc_train/4/136707/16640 +- tomm20_hipsc_train/4/136707/16795 +- tomm20_hipsc_train/4/136708/16427 +- tomm20_hipsc_train/4/136710/15363 +- tomm20_hipsc_train/4/136710/15740 +- tomm20_hipsc_train/4/136710/16002 +- tomm20_hipsc_train/4/136710/16572 +- tomm20_hipsc_train/4/136712/15798 +- tomm20_hipsc_train/4/136712/17080 +- tomm20_hipsc_train/4/136712/17179 +- tomm20_hipsc_train/4/136714/15190 +- tomm20_hipsc_train/4/136717/16904 +- tomm20_hipsc_train/4/136719/15840 +- tomm20_hipsc_train/4/136719/16707 +- tomm20_hipsc_train/4/136721/15487 +- tomm20_hipsc_train/4/136721/15588 +- tomm20_hipsc_train/4/136721/15624 +- tomm20_hipsc_train/4/136721/16107 +- tomm20_hipsc_train/4/136723/16663 +- tomm20_hipsc_train/4/136723/16687 +- tomm20_hipsc_train/4/136723/16763 +- tomm20_hipsc_train/4/136725/16272 +- tomm20_hipsc_train/4/136736/15292 +- tomm20_hipsc_train/4/136736/16364 +- tomm20_hipsc_train/4/136738/14381 +- tomm20_hipsc_train/4/136738/16770 +- tomm20_hipsc_train/4/22132/2808 +- tomm20_hipsc_train/4/22132/2820 +- tomm20_hipsc_train/4/22133/2782 +- tomm20_hipsc_train/4/22133/2830 +- tomm20_hipsc_train/4/22134/2802 +- tomm20_hipsc_train/4/22135/2819 +- tomm20_hipsc_train/4/22135/2821 +- tomm20_hipsc_train/4/22325/3154 +- tomm20_hipsc_train/4/22326/3079 +- tomm20_hipsc_train/4/22326/3121 +- tomm20_hipsc_train/4/22326/3139 +- tomm20_hipsc_train/4/22327/3081 +- tomm20_hipsc_train/4/22327/3087 +- tomm20_hipsc_train/4/22327/3117 +- tomm20_hipsc_train/4/22327/3120 +- tomm20_hipsc_train/4/22327/3126 +- tomm20_hipsc_train/4/22327/3144 +- tomm20_hipsc_train/4/22327/3153 +- tomm20_hipsc_train/4/22328/3077 +- tomm20_hipsc_train/4/22328/3099 +- tomm20_hipsc_train/4/22328/3125 +- tomm20_hipsc_train/4/22328/3135 +- tomm20_hipsc_train/4/22339/3095 +- tomm20_hipsc_train/4/22339/3105 +- tomm20_hipsc_train/4/22339/3116 +- tomm20_hipsc_train/4/22339/3129 +- tomm20_hipsc_train/4/22339/3150 +- tomm20_hipsc_train/4/22340/3071 +- tomm20_hipsc_train/4/22612/2918 +- tomm20_hipsc_train/4/22612/2992 +- tomm20_hipsc_train/4/22613/2897 +- tomm20_hipsc_train/4/22614/2972 +- tomm20_hipsc_train/4/22615/2913 +- tomm20_hipsc_train/4/22615/2970 +- tomm20_hipsc_train/4/22624/2899 +- tomm20_hipsc_train/4/22624/2911 +- tomm20_hipsc_train/4/22624/2920 +- tomm20_hipsc_train/4/22625/2914 +- tomm20_hipsc_train/4/22709/3112 +- tomm20_hipsc_train/4/22711/3072 +- tomm20_hipsc_train/4/22720/3100 +- tomm20_hipsc_train/4/22720/3110 +- tomm20_hipsc_train/4/22721/3062 +- tomm20_hipsc_train/4/22721/3067 +- tomm20_hipsc_train/4/22900/3316 +- tomm20_hipsc_train/4/22901/3283 +- tomm20_hipsc_train/4/22901/3285 +- tomm20_hipsc_train/4/22902/3279 +- tomm20_hipsc_train/4/22915/3292 +- tomm20_hipsc_train/4/22916/3312 +- tomm20_hipsc_train/4/23284/3464 +- tomm20_hipsc_train/4/23284/3468 +- tomm20_hipsc_train/4/23284/3487 +- tomm20_hipsc_train/4/23284/3499 +- tomm20_hipsc_train/4/23285/3466 +- tomm20_hipsc_train/4/23285/3509 +- tomm20_hipsc_train/4/23286/3454 +- tomm20_hipsc_train/4/23286/3515 +- tomm20_hipsc_train/4/23287/3465 +- tomm20_hipsc_train/4/23287/3484 +- tomm20_hipsc_train/4/23383/3173 +- tomm20_hipsc_train/4/23383/3255 +- tomm20_hipsc_train/4/23384/3187 +- tomm20_hipsc_train/4/23384/3201 +- tomm20_hipsc_train/4/23392/3239 +- tomm20_hipsc_train/4/23393/3259 +- tomm20_hipsc_train/4/23394/3192 +- tomm20_hipsc_train/4/23394/3251 +- tomm20_hipsc_train/4/23476/3329 +- tomm20_hipsc_train/4/23478/3324 +- tomm20_hipsc_train/4/23478/3328 +- tomm20_hipsc_train/4/23478/3363 +- tomm20_hipsc_train/4/23479/3347 +- tomm20_hipsc_train/4/23572/3536 +- tomm20_hipsc_train/4/23573/3513 +- tomm20_hipsc_train/4/23573/3519 +- tomm20_hipsc_train/4/23573/3527 +- tomm20_hipsc_train/4/23573/3538 +- tomm20_hipsc_train/4/23574/3492 +- tomm20_hipsc_train/4/23574/3504 +- tomm20_hipsc_train/4/23585/3498 +- tomm20_hipsc_train/4/23764/3403 +- tomm20_hipsc_train/4/23766/3411 +- tomm20_hipsc_train/4/23767/3421 +- tomm20_hipsc_train/4/23767/3425 +- tomm20_hipsc_train/4/23778/3408 +- tomm20_hipsc_train/4/24148/3551 +- tomm20_hipsc_train/4/24148/3554 +- tomm20_hipsc_train/4/24148/3572 +- tomm20_hipsc_train/4/24149/3555 +- tomm20_hipsc_train/4/24149/3568 +- tomm20_hipsc_train/4/24150/3550 +- tomm20_hipsc_train/4/24150/3562 +- tomm20_hipsc_train/4/24151/3508 +- tomm20_hipsc_train/4/24151/3532 +- tomm20_hipsc_train/4/24151/3547 +- tomm20_hipsc_train/4/24151/3563 +- tomm20_hipsc_train/4/24152/3526 +- tomm20_hipsc_train/4/24152/3545 +- tomm20_hipsc_train/4/24152/3573 +- tomm20_hipsc_train/4/24160/3478 +- tomm20_hipsc_train/4/24160/3564 +- tomm20_hipsc_train/4/24724/3641 +- tomm20_hipsc_train/4/24724/3661 +- tomm20_hipsc_train/4/24724/3688 +- tomm20_hipsc_train/4/24727/3648 +- tomm20_hipsc_train/4/24727/3651 +- tomm20_hipsc_train/4/24727/3659 +- tomm20_hipsc_train/4/24727/3660 +- tomm20_hipsc_train/4/24728/3655 +- tomm20_hipsc_train/4/24728/3678 +- tomm20_hipsc_train/4/24739/3638 +- tomm20_hipsc_train/4/24739/3644 +- tomm20_hipsc_train/4/24739/3647 +- tomm20_hipsc_train/4/24739/3681 +- tomm20_hipsc_train/4/24739/3683 +- tomm20_hipsc_train/4/24739/3703 +- tomm20_hipsc_train/4/24740/3657 +- tomm20_hipsc_train/4/24740/3701 +- tomm20_hipsc_train/4/24820/14 +- tomm20_hipsc_train/4/24820/15 +- tomm20_hipsc_train/4/24820/18 +- tomm20_hipsc_train/4/24820/3 +- tomm20_hipsc_train/4/24821/11 +- tomm20_hipsc_train/4/24822/1 +- tomm20_hipsc_train/4/24833/2 +- tomm20_hipsc_train/4/24833/27 +- tomm20_hipsc_train/4/24834/23 +- tomm20_hipsc_train/4/24928/3614 +- tomm20_hipsc_train/4/24929/3580 +- tomm20_hipsc_train/4/24929/3600 +- tomm20_hipsc_train/4/24929/3603 +- tomm20_hipsc_train/4/24929/3608 +- tomm20_hipsc_train/4/24930/3583 +- tomm20_hipsc_train/4/24930/3617 +- tomm20_hipsc_train/4/24931/3581 +- tomm20_hipsc_train/4/24931/3606 +- tomm20_hipsc_train/4/24932/3598 +- tomm20_hipsc_train/4/25204/3792 +- tomm20_hipsc_train/4/25205/3812 +- tomm20_hipsc_train/4/25206/3806 +- tomm20_hipsc_train/4/25208/3798 +- tomm20_hipsc_train/4/25208/3815 +- tomm20_hipsc_train/4/25208/3821 +- tomm20_hipsc_train/4/25216/3794 +- tomm20_hipsc_train/4/25781/3833 +- tomm20_hipsc_train/4/25781/3843 +- tomm20_hipsc_train/4/25781/3854 +- tomm20_hipsc_train/4/25781/3858 +- tomm20_hipsc_train/4/25782/3855 +- tomm20_hipsc_train/4/25783/3849 +- tomm20_hipsc_train/4/25783/3857 +- tomm20_hipsc_train/4/25784/3852 +- tomm20_hipsc_train/4/27798/2892 +- tomm20_hipsc_train/4/27799/2871 +- tomm20_hipsc_train/4/27799/2884 +- tomm20_hipsc_train/4/27800/2875 +- tomm20_hipsc_train/4/27808/2862 +- tomm20_hipsc_train/4/27808/2876 +- tomm20_hipsc_train/4/27809/2886 +- tomm20_hipsc_train/4/27892/2930 +- tomm20_hipsc_train/4/27893/2938 +- tomm20_hipsc_train/4/27893/2950 +- tomm20_hipsc_train/4/27894/2945 +- tomm20_hipsc_train/4/27896/2943 +- tomm20_hipsc_train/4/27904/2979 +- tomm20_hipsc_train/4/27906/2983 +- tomm20_hipsc_train/4/27988/3025 +- tomm20_hipsc_train/4/27990/3026 +- tomm20_hipsc_train/4/27992/3014 +- tomm20_hipsc_train/4/28000/3038 +- tomm20_hipsc_train/4/28001/3005 +- tomm20_hipsc_train/4/28001/3027 +- tomm20_hipsc_train/4/28001/3031 +- tomm20_hipsc_train/4/28002/3007 +- tomm20_hipsc_train/4/28002/3022 +- tomm20_hipsc_train/4/28002/3036 +- tomm20_hipsc_train/4/28084/3232 +- tomm20_hipsc_train/4/28084/3254 +- tomm20_hipsc_train/4/28085/3213 +- tomm20_hipsc_train/4/28085/3258 +- tomm20_hipsc_train/4/28086/3211 +- tomm20_hipsc_train/4/28086/3236 +- tomm20_hipsc_train/4/28087/3240 +- tomm20_hipsc_train/4/28087/3242 +- tomm20_hipsc_train/4/28087/3266 +- tomm20_hipsc_train/4/28088/3205 +- tomm20_hipsc_train/4/28088/3238 +- tomm20_hipsc_train/4/28088/3268 +- tomm20_hipsc_train/4/28756/3366 +- tomm20_hipsc_train/4/28758/3397 +- tomm20_hipsc_train/4/28759/3399 +- tomm20_hipsc_train/4/28760/3388 +- tomm20_hipsc_train/4/28760/3402 +- tomm20_hipsc_train/4/28769/3372 +- tomm20_hipsc_train/4/28770/3377 +- tomm20_hipsc_train/4/29045/3774 +- tomm20_hipsc_train/4/29045/3779 +- tomm20_hipsc_train/4/29045/3782 +- tomm20_hipsc_train/4/29046/3750 +- tomm20_hipsc_train/4/29046/3762 +- tomm20_hipsc_train/4/29047/3766 +- tomm20_hipsc_train/4/29058/3772 +- tomm20_hipsc_train/4/29059/3758 +- tomm20_hipsc_train/4/29059/3765 +- tomm20_hipsc_train/4/29060/3753 +- tomm20_hipsc_train/4/29140/3684 +- tomm20_hipsc_train/4/29140/3716 +- tomm20_hipsc_train/4/29140/3726 +- tomm20_hipsc_train/4/29141/3709 +- tomm20_hipsc_train/4/29141/3719 +- tomm20_hipsc_train/4/29141/3728 +- tomm20_hipsc_train/4/29141/3742 +- tomm20_hipsc_train/4/29142/3695 +- tomm20_hipsc_train/4/29142/3739 +- tomm20_hipsc_train/4/29143/3680 +- tomm20_hipsc_train/4/29152/3708 +- tomm20_hipsc_train/4/29152/3712 +- tomm20_hipsc_train/4/29152/3723 +- tomm20_hipsc_train/4/29153/3725 +- tomm20_hipsc_train/4/29155/3689 +- tomm20_hipsc_train/4/29155/3714 +- tomm20_hipsc_train/4/29332/3865 +- tomm20_hipsc_train/4/29333/3868 +- tomm20_hipsc_train/4/29333/3908 +- tomm20_hipsc_train/4/29334/3889 +- tomm20_hipsc_train/4/29334/3890 +- tomm20_hipsc_train/4/29334/3892 +- tomm20_hipsc_train/4/29335/3867 +- tomm20_hipsc_train/4/29335/3879 +- tomm20_hipsc_train/4/29335/3900 +- tomm20_hipsc_train/4/30292/3893 +- tomm20_hipsc_train/4/30292/3913 +- tomm20_hipsc_train/4/30293/3905 +- tomm20_hipsc_train/4/30294/15038 +- tomm20_hipsc_train/4/30294/16432 +- tomm20_hipsc_train/4/30294/3906 +- tomm20_hipsc_train/4/30294/3912 +- tomm20_hipsc_train/4/30304/3866 +- tomm20_hipsc_train/4/30308/3869 +- tomm20_hipsc_train/4/30308/3871 +- tomm20_hipsc_train/4/30389/16772 +- tomm20_hipsc_train/4/30392/16282 +- tomm20_hipsc_train/4/30677/15449 +- tomm20_hipsc_train/4/30677/16684 +- tomm20_hipsc_train/4/30677/16969 +- tomm20_hipsc_train/4/30679/15295 +- tomm20_hipsc_train/4/30679/15878 +- tomm20_hipsc_train/4/30680/17051 +- tomm20_hipsc_train/4/30688/15165 +- tomm20_hipsc_train/4/30689/15310 +- tomm20_hipsc_train/4/5140/925 +- tomm20_hipsc_train/4/5140/933 +- tomm20_hipsc_train/4/5140/950 +- tomm20_hipsc_train/4/5141/928 +- tomm20_hipsc_train/4/5141/940 +- tomm20_hipsc_train/4/5143/954 +- tomm20_hipsc_train/4/5144/943 +- tomm20_hipsc_train/4/5236/869 +- tomm20_hipsc_train/4/5236/913 +- tomm20_hipsc_train/4/5237/858 +- tomm20_hipsc_train/4/5238/1043 +- tomm20_hipsc_train/4/5238/815 +- tomm20_hipsc_train/4/5238/867 +- tomm20_hipsc_train/4/5238/873 +- tomm20_hipsc_train/4/5238/938 +- tomm20_hipsc_train/4/5239/888 +- tomm20_hipsc_train/4/5248/1038 +- tomm20_hipsc_train/4/5248/910 +- tomm20_hipsc_train/4/5250/902 +- tomm20_hipsc_train/4/5910/824 +- tomm20_hipsc_train/4/5912/841 +- tomm20_hipsc_train/4/5920/843 +- tomm20_hipsc_train/4/5921/828 +- tomm20_hipsc_train/4/5923/837 +- tomm20_hipsc_train/4/5923/853 +- tomm20_hipsc_train/4/5923/855 +- tomm20_hipsc_train/4/5924/819 +- tomm20_hipsc_train/4/6485/1007 +- tomm20_hipsc_train/4/6485/1011 +- tomm20_hipsc_train/4/6485/978 +- tomm20_hipsc_train/4/6485/980 +- tomm20_hipsc_train/4/6485/997 +- tomm20_hipsc_train/4/6486/1002 +- tomm20_hipsc_train/4/6486/1006 +- tomm20_hipsc_train/4/6486/1012 +- tomm20_hipsc_train/4/6486/1022 +- tomm20_hipsc_train/4/6486/965 +- tomm20_hipsc_train/4/6486/968 +- tomm20_hipsc_train/4/6486/981 +- tomm20_hipsc_train/4/6487/1015 +- tomm20_hipsc_train/4/6487/1020 +- tomm20_hipsc_train/4/6487/993 +- tomm20_hipsc_train/4/6497/1014 +- tomm20_hipsc_train/4/6497/1017 +- tomm20_hipsc_train/4/6497/1025 +- tomm20_hipsc_train/4/6497/976 +- tomm20_hipsc_train/4/6774/1134 +- tomm20_hipsc_train/4/6774/1218 +- tomm20_hipsc_train/4/6775/1100 +- tomm20_hipsc_train/4/6775/1176 +- tomm20_hipsc_train/4/6775/1187 +- tomm20_hipsc_train/4/6775/1191 +- tomm20_hipsc_train/4/6775/1193 +- tomm20_hipsc_train/4/6775/1195 +- tomm20_hipsc_train/4/6775/1228 +- tomm20_hipsc_train/4/6775/1232 +- tomm20_hipsc_train/4/6775/1236 +- tomm20_hipsc_train/4/6775/1240 +- tomm20_hipsc_train/4/6775/1248 +- tomm20_hipsc_train/4/6776/1153 +- tomm20_hipsc_train/4/6776/1185 +- tomm20_hipsc_train/4/6776/1199 +- tomm20_hipsc_train/4/7156/1104 +- tomm20_hipsc_train/4/7157/1102 +- tomm20_hipsc_train/4/7158/1105 +- tomm20_hipsc_train/4/7158/1119 +- tomm20_hipsc_train/4/7158/1123 +- tomm20_hipsc_train/4/7348/1326 +- tomm20_hipsc_train/4/7349/1348 +- tomm20_hipsc_train/4/7349/1352 +- tomm20_hipsc_train/4/7636/1269 +- tomm20_hipsc_train/4/7636/1272 +- tomm20_hipsc_train/4/7636/1287 +- tomm20_hipsc_train/4/7637/1270 +- tomm20_hipsc_train/4/7637/1293 +- tomm20_hipsc_train/4/7638/1279 +- tomm20_hipsc_train/4/7650/1252 +- tomm20_hipsc_train/4/7650/1278 +- tomm20_hipsc_train/4/7650/1288 +- tomm20_hipsc_train/4/8214/897 +- tomm20_hipsc_train/4/8214/903 +- tomm20_hipsc_train/4/8214/907 +- tomm20_hipsc_train/4/8225/899 +- tomm20_hipsc_train/4/8225/904 +- tomm20_hipsc_train/4/8309/1032 +- tomm20_hipsc_train/4/8310/1091 +- tomm20_hipsc_train/4/8311/1074 +- tomm20_hipsc_train/4/8692/1096 +- tomm20_hipsc_train/4/8692/1114 +- tomm20_hipsc_train/4/8692/1227 +- tomm20_hipsc_train/4/8695/1082 +- tomm20_hipsc_train/4/8695/1198 +- tomm20_hipsc_train/4/8695/1211 +- tomm20_hipsc_train/4/8695/1215 +- tomm20_hipsc_train/4/8696/1079 +- tomm20_hipsc_train/4/8705/1221 +- tomm20_hipsc_train/4/8706/1072 +- tomm20_hipsc_train/4/8707/1219 +- tomm20_hipsc_train/4/8708/1127 +- tomm20_hipsc_train/4/8708/1173 +- tomm20_hipsc_train/4/8708/1213 +- tomm20_hipsc_train/4/8708/1233 +- tomm20_hipsc_train/4/8980/1167 +- tomm20_hipsc_train/4/8980/1168 +- tomm20_hipsc_train/4/8980/1175 +- tomm20_hipsc_train/4/8980/1181 +- tomm20_hipsc_train/4/8981/1143 +- tomm20_hipsc_train/4/8981/1155 +- tomm20_hipsc_train/4/8982/1150 +- tomm20_hipsc_train/4/8982/1163 +- tomm20_hipsc_train/4/9748/15080 +- tomm20_hipsc_train/4/9748/15365 +- tomm20_hipsc_train/4/9748/15563 +- tomm20_hipsc_train/4/9748/15711 +- tomm20_hipsc_train/4/9748/15871 +- tomm20_hipsc_train/4/9748/16327 +- tomm20_hipsc_train/4/9748/16440 +- tomm20_hipsc_train/4/9748/16524 +- tomm20_hipsc_train/4/9748/16929 +- tomm20_hipsc_train/4/9748/17154 +- tomm20_hipsc_train/42/135521/14270 +- tomm20_hipsc_train/42/135523/14265 +- tomm20_hipsc_train/42/135524/14251 +- tomm20_hipsc_train/42/135525/14254 +- tomm20_hipsc_train/42/135525/15339 +- tomm20_hipsc_train/42/135526/14250 +- tomm20_hipsc_train/42/135526/14256 +- tomm20_hipsc_train/42/135526/14257 +- tomm20_hipsc_train/42/135614/14199 +- tomm20_hipsc_train/42/135614/14210 +- tomm20_hipsc_train/42/135615/14176 +- tomm20_hipsc_train/42/135615/14194 +- tomm20_hipsc_train/42/135615/14209 +- tomm20_hipsc_train/42/135616/14159 +- tomm20_hipsc_train/42/135616/14160 +- tomm20_hipsc_train/42/135616/14180 +- tomm20_hipsc_train/42/135616/14191 +- tomm20_hipsc_train/42/135617/14162 +- tomm20_hipsc_train/42/135617/14200 +- tomm20_hipsc_train/42/135617/14213 +- tomm20_hipsc_train/42/135617/14218 +- tomm20_hipsc_train/42/135618/14161 +- tomm20_hipsc_train/42/135618/14170 +- tomm20_hipsc_train/42/135618/14177 +- tomm20_hipsc_train/42/135618/14203 +- tomm20_hipsc_train/42/135619/14174 +- tomm20_hipsc_train/42/135619/14208 +- tomm20_hipsc_train/42/135620/14192 +- tomm20_hipsc_train/42/135620/14202 +- tomm20_hipsc_train/42/135622/14167 +- tomm20_hipsc_train/42/135622/14181 +- tomm20_hipsc_train/42/135622/14197 +- tomm20_hipsc_train/42/135622/14217 +- tomm20_hipsc_train/42/136130/14294 +- tomm20_hipsc_train/42/136130/14297 +- tomm20_hipsc_train/42/136130/14305 +- tomm20_hipsc_train/42/136131/14307 +- tomm20_hipsc_train/42/136131/14315 +- tomm20_hipsc_train/42/136131/14319 +- tomm20_hipsc_train/42/136131/14335 +- tomm20_hipsc_train/42/136132/14322 +- tomm20_hipsc_train/42/136132/14326 +- tomm20_hipsc_train/42/136132/14332 +- tomm20_hipsc_train/42/136133/14283 +- tomm20_hipsc_train/42/136133/14285 +- tomm20_hipsc_train/42/136134/14291 +- tomm20_hipsc_train/42/136134/14328 +- tomm20_hipsc_train/42/136135/14316 +- tomm20_hipsc_train/42/136135/14321 +- tomm20_hipsc_train/42/136136/14279 +- tomm20_hipsc_train/42/137952/15541 +- tomm20_hipsc_train/42/137952/16945 +- tomm20_hipsc_train/42/137952/17148 +- tomm20_hipsc_train/42/137953/16951 +- tomm20_hipsc_train/42/137954/15782 +- tomm20_hipsc_train/42/137954/16856 +- tomm20_hipsc_train/42/137954/16893 +- tomm20_hipsc_train/42/137955/15694 +- tomm20_hipsc_train/42/137955/15892 +- tomm20_hipsc_train/42/137955/16043 +- tomm20_hipsc_train/42/137956/16613 +- tomm20_hipsc_train/42/137956/17196 +- tomm20_hipsc_train/42/137956/17233 +- tomm20_a549_mantis_2024_10_29_train/B/4/000000 +- tomm20_a549_mantis_2024_10_29_train/B/4/000001 +- tomm20_a549_mantis_2024_10_29_train/B/4/001000 +- tomm20_a549_mantis_2024_10_29_train/B/4/001001 +- tomm20_a549_mantis_2024_10_29_train/B/4/002001 +- tomm20_a549_mantis_2024_11_05_train/B/4/001001 +- tomm20_a549_mantis_2024_11_05_train/B/4/002000 +- tomm20_a549_mantis_2024_11_05_train/B/4/002001 +- tomm20_a549_mantis_2024_11_21_train/B/1/001001 +- tomm20_a549_mantis_2024_11_21_train/B/3/000000 +- tomm20_a549_mantis_2024_11_21_train/B/3/000001 +- tomm20_a549_mantis_2024_11_21_train/B/3/001000 +- tomm20_a549_mantis_2024_11_21_train/B/3/001001 +- tomm20_a549_mantis_2025_07_24_train/B/1/001001 +- tomm20_a549_mantis_2025_07_24_train/B/1/002000 +- tomm20_a549_mantis_2025_07_24_train/B/1/002001 +- tomm20_a549_mantis_2025_08_26_train/A/2/001000 +- tomm20_a549_mantis_2025_08_26_train/A/2/001001 +- tomm20_a549_mantis_2025_08_26_train/A/2/001002 +- tomm20_a549_mantis_2025_08_26_train/A/2/002000 +- tomm20_a549_mantis_2025_08_26_train/A/2/002001 +- tomm20_a549_mantis_2025_08_26_train/A/2/002002 +test_fovs: +- tomm20_hipsc_test/4/10612/1362 +- tomm20_hipsc_test/4/10624/1349 +- tomm20_hipsc_test/4/11380/1459 +- tomm20_hipsc_test/4/11380/1471 +- tomm20_hipsc_test/4/11384/1404 +- tomm20_hipsc_test/4/11476/16725 +- tomm20_hipsc_test/4/11477/1493 +- tomm20_hipsc_test/4/11492/1472 +- tomm20_hipsc_test/4/11575/1394 +- tomm20_hipsc_test/4/11670/1462 +- tomm20_hipsc_test/4/11680/1686 +- tomm20_hipsc_test/4/11682/1660 +- tomm20_hipsc_test/4/136707/16604 +- tomm20_hipsc_test/4/22132/2823 +- tomm20_hipsc_test/4/22133/2798 +- tomm20_hipsc_test/4/22135/2792 +- tomm20_hipsc_test/4/22135/2822 +- tomm20_hipsc_test/4/22325/3131 +- tomm20_hipsc_test/4/22326/3141 +- tomm20_hipsc_test/4/22327/3137 +- tomm20_hipsc_test/4/22340/3097 +- tomm20_hipsc_test/4/22612/2958 +- tomm20_hipsc_test/4/22612/2986 +- tomm20_hipsc_test/4/23285/3452 +- tomm20_hipsc_test/4/23286/3512 +- tomm20_hipsc_test/4/23381/3195 +- tomm20_hipsc_test/4/23382/3245 +- tomm20_hipsc_test/4/23384/3170 +- tomm20_hipsc_test/4/23384/3253 +- tomm20_hipsc_test/4/23394/3196 +- tomm20_hipsc_test/4/23572/3529 +- tomm20_hipsc_test/4/23768/3424 +- tomm20_hipsc_test/4/23777/3418 +- tomm20_hipsc_test/4/24149/3481 +- tomm20_hipsc_test/4/24150/3537 +- tomm20_hipsc_test/4/24724/3645 +- tomm20_hipsc_test/4/24724/3649 +- tomm20_hipsc_test/4/24834/13 +- tomm20_hipsc_test/4/24930/3599 +- tomm20_hipsc_test/4/24931/3592 +- tomm20_hipsc_test/4/24932/3588 +- tomm20_hipsc_test/4/25207/3818 +- tomm20_hipsc_test/4/25207/3824 +- tomm20_hipsc_test/4/27798/2891 +- tomm20_hipsc_test/4/27892/2961 +- tomm20_hipsc_test/4/27990/3010 +- tomm20_hipsc_test/4/27990/3012 +- tomm20_hipsc_test/4/27991/3009 +- tomm20_hipsc_test/4/27991/3028 +- tomm20_hipsc_test/4/28001/3016 +- tomm20_hipsc_test/4/28084/3200 +- tomm20_hipsc_test/4/28084/3214 +- tomm20_hipsc_test/4/28086/3250 +- tomm20_hipsc_test/4/28087/3224 +- tomm20_hipsc_test/4/28756/3370 +- tomm20_hipsc_test/4/28760/3390 +- tomm20_hipsc_test/4/29142/3718 +- tomm20_hipsc_test/4/29142/3720 +- tomm20_hipsc_test/4/29143/3679 +- tomm20_hipsc_test/4/29152/3740 +- tomm20_hipsc_test/4/29332/3860 +- tomm20_hipsc_test/4/29336/3885 +- tomm20_hipsc_test/4/29336/3896 +- tomm20_hipsc_test/4/30292/3909 +- tomm20_hipsc_test/4/30294/3901 +- tomm20_hipsc_test/4/30391/15032 +- tomm20_hipsc_test/4/30679/3933 +- tomm20_hipsc_test/4/5141/926 +- tomm20_hipsc_test/4/5143/953 +- tomm20_hipsc_test/4/5240/1073 +- tomm20_hipsc_test/4/5912/823 +- tomm20_hipsc_test/4/6485/990 +- tomm20_hipsc_test/4/6486/989 +- tomm20_hipsc_test/4/6486/991 +- tomm20_hipsc_test/4/6497/1009 +- tomm20_hipsc_test/4/6776/1122 +- tomm20_hipsc_test/4/7349/1359 +- tomm20_hipsc_test/4/7638/1280 +- tomm20_hipsc_test/4/7639/1264 +- tomm20_hipsc_test/4/7650/1285 +- tomm20_hipsc_test/4/8228/886 +- tomm20_hipsc_test/4/8228/893 +- tomm20_hipsc_test/4/8228/906 +- tomm20_hipsc_test/4/8692/1235 +- tomm20_hipsc_test/4/8705/1209 +- tomm20_hipsc_test/4/8705/1225 +- tomm20_hipsc_test/4/8982/1147 +- tomm20_hipsc_test/4/9748/16392 +- tomm20_hipsc_test/4/9748/16574 +- tomm20_hipsc_test/4/9748/16977 +- tomm20_hipsc_test/4/9749/16734 +- tomm20_hipsc_test/42/135525/16168 +- tomm20_hipsc_test/42/135615/14189 +- tomm20_hipsc_test/42/135621/14220 +- tomm20_hipsc_test/42/136130/14325 +- tomm20_hipsc_test/42/136133/14302 +- tomm20_hipsc_test/42/136134/14300 +- tomm20_hipsc_test/42/136136/14317 +- tomm20_hipsc_test/42/136136/14320 +- tomm20_hipsc_test/42/137953/15532 +- tomm20_a549_mantis_2024_11_05_test/B/4/000000 +- tomm20_a549_mantis_2024_11_05_test/B/4/000001 +- tomm20_a549_mantis_2024_11_05_test/B/4/001000 +- tomm20_a549_mantis_2024_11_21_test/B/1/000000 +- tomm20_a549_mantis_2024_11_21_test/B/1/000001 +- tomm20_a549_mantis_2024_11_21_test/B/1/001000 +- tomm20_a549_mantis_2025_07_24_test/B/1/000000 +- tomm20_a549_mantis_2025_07_24_test/B/1/000001 +- tomm20_a549_mantis_2025_07_24_test/B/1/001000 +- tomm20_a549_mantis_2025_08_26_test/A/2/000000 +- tomm20_a549_mantis_2025_08_26_test/A/2/000001 +- tomm20_a549_mantis_2025_08_26_test/A/2/000002 diff --git a/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_10_29_A549_TOMM20_ZIKV_DENV.yaml b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_10_29_A549_TOMM20_ZIKV_DENV.yaml new file mode 100644 index 000000000..7259a67ec --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_10_29_A549_TOMM20_ZIKV_DENV.yaml @@ -0,0 +1,47 @@ +# A549 mantis platemap — 2024_10_29_A549_TOMM20_ZIKV_DENV +# +# Cross-referenced from preprocessing/dynacell-a549/2024_10_29_A549_TOMM20_ZIKV_DENV_platemap.csv +# and the dynacell zarr under run_20260403_043348. +# +# CSV plate plan: +# B/1, B/2 (TOMM20-GFP wildtype mock + DENV) +# C/2 (TOMM20-GFP wildtype ZIKV) +# B/3, C/3 (TOMM20-GFP pAL17 viral-sensor variants — mock + ZIKV) +# B/4, C/4 (TOMM20-GFP pAL40 viral-sensor variants — mock + DENV) +# The dynacell zarr only carries B/3, B/4, C/3, C/4 — the four viral-sensor +# wells. The earlier Airtable-only sync omitted B/3 and C/3 as biology-QC +# failed; they are re-included here for the train pool. pAL17 and pAL40 +# both image TOMM20 on the same GFP cube as wildtype; the unused mCherry +# sensor channel is dropped at assembly time via gene_channel_map, so +# these FOVs are bytewise indistinguishable from wildtype FOVs at the +# model's input. +# +# Target: TOMM20 (mitochondria) on GFP cube. Train-only plate per plan. + +experiment: 2024_10_29_A549_TOMM20_ZIKV_DENV +run_dir: run_20260403_043348 +zarr_filename: 2024_10_29_A549_TOMM20_ZIKV_DENV.zarr + +native_delta_t_min: 30 +hpi_start: 3.5 +native_t: 20 + +wells: + B/3: + condition: mock + gene_channel_map: + "GFP EX488 EM525-45": tomm20 + B/4: + condition: mock + gene_channel_map: + "GFP EX488 EM525-45": tomm20 + C/3: + condition: ZIKV + moi: 5 + gene_channel_map: + "GFP EX488 EM525-45": tomm20 + C/4: + condition: DENV + moi: 5 + gene_channel_map: + "GFP EX488 EM525-45": tomm20 diff --git a/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_10_31_A549_SEC61_ZIKV_DENV.yaml b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_10_31_A549_SEC61_ZIKV_DENV.yaml new file mode 100644 index 000000000..4bed7f945 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_10_31_A549_SEC61_ZIKV_DENV.yaml @@ -0,0 +1,45 @@ +# A549 mantis platemap — 2024_10_31_A549_SEC61_ZIKV_DENV +# +# Cross-referenced from preprocessing/dynacell-a549/2024_10_31_A549_SEC61_ZIKV_DENV_platemap.csv +# and the dynacell zarr under run_20260327_141259. +# +# CSV plate plan: +# B/1, B/2 (SEC61B-GFP wildtype mock + DENV) +# C/2 (SEC61B-GFP wildtype ZIKV) +# B/3, C/3 (SEC61B-GFP pAL17 viral-sensor variants — mock + ZIKV) +# B/4, C/4 (SEC61B-GFP pAL40 viral-sensor variants — mock + DENV) +# The dynacell zarr only carries C/2, C/3, C/4 — every B-row well failed +# biology QC at the Airtable stage and was not preserved in the dynacell +# preprocessing run. The earlier Airtable-only sync also omitted C/3 +# (biology-QC failed); it is re-included here for the train pool. pAL17 +# and pAL40 both image SEC61B on the same GFP cube as wildtype; the +# unused mCherry sensor channel is dropped at assembly time via +# gene_channel_map, so these FOVs are bytewise indistinguishable from +# wildtype FOVs at the model's input. +# +# Target: SEC61B (ER) on GFP cube. + +experiment: 2024_10_31_A549_SEC61_ZIKV_DENV +run_dir: run_20260327_141259 +zarr_filename: 2024_10_31_A549_SEC61_ZIKV_DENV.zarr + +native_delta_t_min: 30 +hpi_start: 4.0 +native_t: 24 + +wells: + C/2: + condition: ZIKV + moi: 5 + gene_channel_map: + "GFP EX488 EM525-45": sec61b + C/3: + condition: ZIKV + moi: 5 + gene_channel_map: + "GFP EX488 EM525-45": sec61b + C/4: + condition: DENV + moi: 5 + gene_channel_map: + "GFP EX488 EM525-45": sec61b diff --git a/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_11_05_A549_TOMM20_ZIKV_DENV.yaml b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_11_05_A549_TOMM20_ZIKV_DENV.yaml new file mode 100644 index 000000000..243d24917 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_11_05_A549_TOMM20_ZIKV_DENV.yaml @@ -0,0 +1,47 @@ +# A549 mantis platemap — 2024_11_05_A549_TOMM20_ZIKV_DENV +# +# Cross-referenced from preprocessing/dynacell-a549/2024_11_05_A549_TOMM20_ZIKV_DENV_platemap.csv +# and the dynacell zarr under run_20260403_014617. +# +# CSV plate plan: +# B/1, B/2 (TOMM20-GFP wildtype mock + DENV) +# C/2 (TOMM20-GFP wildtype ZIKV) +# B/3, C/3 (TOMM20-GFP pAL17 viral-sensor variants — mock + ZIKV) +# B/4, C/4 (TOMM20-GFP pAL40 viral-sensor variants — mock + DENV) +# The dynacell zarr only carries B/3, B/4, C/3, C/4 — the four viral-sensor +# wells. The earlier Airtable-only sync omitted B/3 and C/3 as biology-QC +# failed; they are re-included here for the train pool. pAL17 and pAL40 +# both image TOMM20 on the same GFP cube as wildtype; the unused mCherry +# sensor channel is dropped at assembly time via gene_channel_map, so +# these FOVs are bytewise indistinguishable from wildtype FOVs at the +# model's input. +# +# Target: TOMM20 (mitochondria) on GFP cube. + +experiment: 2024_11_05_A549_TOMM20_ZIKV_DENV +run_dir: run_20260403_014617 +zarr_filename: 2024_11_05_A549_TOMM20_ZIKV_DENV.zarr + +native_delta_t_min: 30 +hpi_start: 4.5 +native_t: 43 + +wells: + B/3: + condition: mock + gene_channel_map: + "GFP EX488 EM525-45": tomm20 + B/4: + condition: mock + gene_channel_map: + "GFP EX488 EM525-45": tomm20 + C/3: + condition: ZIKV + moi: 5 + gene_channel_map: + "GFP EX488 EM525-45": tomm20 + C/4: + condition: DENV + moi: 5 + gene_channel_map: + "GFP EX488 EM525-45": tomm20 diff --git a/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_11_07_A549_SEC61_DENV.yaml b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_11_07_A549_SEC61_DENV.yaml new file mode 100644 index 000000000..07c7ad547 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_11_07_A549_SEC61_DENV.yaml @@ -0,0 +1,36 @@ +# A549 mantis platemap — 2024_11_07_A549_SEC61_DENV +# +# Derived from configs/datasets/a549-mantis/airtable/2024_11_07_A549_SEC61_DENV.json +# (all 16 FOV rows). See README.md in that directory for the sync workflow. +# +# Target: SEC61B (ER) on GFP cube, all wells. + +experiment: 2024_11_07_A549_SEC61_DENV +run_dir: run_20260325_130901 +zarr_filename: 2024_11_07_A549_SEC61_DENV.zarr + +native_delta_t_min: 10 +hpi_start: 4.0 +native_t: 109 + +# All wells image simultaneously; hpi_start is plate-level (infection clock). +# mock wells are labeled against the same clock by convention. +wells: + B/1: + condition: mock + gene_channel_map: + "GFP EX488 EM525-45": sec61b + B/2: + condition: DENV + moi: 5 + gene_channel_map: + "GFP EX488 EM525-45": sec61b + B/3: + condition: mock + gene_channel_map: + "GFP EX488 EM525-45": sec61b + C/2: + condition: DENV + moi: 5 + gene_channel_map: + "GFP EX488 EM525-45": sec61b diff --git a/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_11_21_A549_TOMM20_DENV.yaml b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_11_21_A549_TOMM20_DENV.yaml new file mode 100644 index 000000000..5df0670b6 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2024_11_21_A549_TOMM20_DENV.yaml @@ -0,0 +1,37 @@ +# A549 mantis platemap — 2024_11_21_A549_TOMM20_DENV +# +# Derived from configs/datasets/a549-mantis/airtable/2024_11_21_A549_TOMM20_DENV.json +# intersected with dynacell zarr positions under run_20260327_101055. +# +# All 16 Airtable rows match all 16 zarr positions exactly. Wells: B/1, B/3 +# (TOMM20 mock); B/2, C/2 (TOMM20 DENV). +# +# Target: TOMM20 (mitochondria) on GFP cube. + +experiment: 2024_11_21_A549_TOMM20_DENV +run_dir: run_20260327_101055 +zarr_filename: 2024_11_21_A549_TOMM20_DENV.zarr + +native_delta_t_min: 10 +hpi_start: 4.0 +native_t: 111 + +wells: + B/1: + condition: mock + gene_channel_map: + "GFP EX488 EM525-45": tomm20 + B/2: + condition: DENV + moi: 5 + gene_channel_map: + "GFP EX488 EM525-45": tomm20 + B/3: + condition: mock + gene_channel_map: + "GFP EX488 EM525-45": tomm20 + C/2: + condition: DENV + moi: 5 + gene_channel_map: + "GFP EX488 EM525-45": tomm20 diff --git a/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV.yaml b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV.yaml new file mode 100644 index 000000000..40dd93b39 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV.yaml @@ -0,0 +1,41 @@ +# A549 mantis platemap — 2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV +# +# Derived from configs/datasets/a549-mantis/airtable/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV.json +# intersected with dynacell zarr positions under run_20260324_220448. +# All 36 Airtable rows match all 36 zarr positions exactly. +# +# Wells: +# A/1 (SEC61B mock), A/2 (SEC61B ZIKV) +# B/1 (TOMM20 mock), B/2 (TOMM20 ZIKV) +# C/1 (G3BP1 mock), C/2 (G3BP1 ZIKV) — OMITTED per plan (G3BP1 not a +# benchmark target here). +# +# Targets: SEC61B (ER) and TOMM20 (mitochondria) on GFP cube. + +experiment: 2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV +run_dir: run_20260324_220448 +zarr_filename: 2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV.zarr + +native_delta_t_min: 30 +hpi_start: 3.5 +native_t: 60 + +wells: + A/1: + condition: mock + gene_channel_map: + "GFP EX488 EM525-45": sec61b + A/2: + condition: ZIKV + moi: 5 + gene_channel_map: + "GFP EX488 EM525-45": sec61b + B/1: + condition: mock + gene_channel_map: + "GFP EX488 EM525-45": tomm20 + B/2: + condition: ZIKV + moi: 5 + gene_channel_map: + "GFP EX488 EM525-45": tomm20 diff --git a/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2025_08_26_A549_SEC61_TOMM20_ZIKV.yaml b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2025_08_26_A549_SEC61_TOMM20_ZIKV.yaml new file mode 100644 index 000000000..71f3478e0 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2025_08_26_A549_SEC61_TOMM20_ZIKV.yaml @@ -0,0 +1,39 @@ +# A549 mantis platemap — 2025_08_26_A549_SEC61_TOMM20_ZIKV +# +# Derived from configs/datasets/a549-mantis/airtable/2025_08_26_A549_SEC61_TOMM20_ZIKV.json +# intersected with dynacell zarr positions under run_20260324_220449. +# All 36 Airtable rows match all 36 zarr positions exactly (9 FOVs per well). +# +# Wells: +# A/1 (SEC61B mock), A/2 (TOMM20 mock) +# B/1 (SEC61B ZIKV), B/2 (TOMM20 ZIKV) +# +# Targets: SEC61B (ER) and TOMM20 (mitochondria) on GFP cube. + +experiment: 2025_08_26_A549_SEC61_TOMM20_ZIKV +run_dir: run_20260324_220449 +zarr_filename: 2025_08_26_A549_SEC61_TOMM20_ZIKV.zarr + +native_delta_t_min: 30 +hpi_start: 3.0 +native_t: 41 + +wells: + A/1: + condition: mock + gene_channel_map: + "GFP EX488 EM525-45": sec61b + A/2: + condition: mock + gene_channel_map: + "GFP EX488 EM525-45": tomm20 + B/1: + condition: ZIKV + moi: 5 + gene_channel_map: + "GFP EX488 EM525-45": sec61b + B/2: + condition: ZIKV + moi: 5 + gene_channel_map: + "GFP EX488 EM525-45": tomm20 diff --git a/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2026_03_26_A549_CAAX_H2B_DENV_ZIKV.yaml b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2026_03_26_A549_CAAX_H2B_DENV_ZIKV.yaml new file mode 100644 index 000000000..fbed1fe47 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/platemaps/2026_03_26_A549_CAAX_H2B_DENV_ZIKV.yaml @@ -0,0 +1,45 @@ +# A549 mantis platemap — 2026_03_26_A549_CAAX_H2B_DENV_ZIKV +# +# First mantis_v2 plate: lateral spacing 0.116 µm/px (mantis_v1 uses +# 0.1494 µm/px). Carries h2b (Nuclei) + caax (Membrane) targets that +# are unique to v2 — no v1 plate has them. +# +# Native t = 11 frames at 120-min stride from hpi=5.0 → frames cover +# hpi {5, 7, ..., 25}. The grid clamp at [5, 23] drops the last frame +# during assembly (10 output frames per FOV). +# +# Channel mapping confirmed by data team 2026-04-26: +# raw mCherry EX561 EM600-37 → caax (Membrane) +# raw Cy5 EX639 EM698-70 → h2b (Nuclei) +# +# Airtable refresh 2026-04-26 returned 3 well-level H2B rows only; no +# CAAX rows and no FOV-level rows. The splits ship without an +# Airtable-derived FOV-level biology-QC filter for this plate; see the +# header comment in splits/2026_03_26_A549_CAAX_H2B_DENV_ZIKV.yaml. + +experiment: 2026_03_26_A549_CAAX_H2B_DENV_ZIKV +run_dir: run_20260423_102349 +zarr_filename: 2026_03_26_A549_CAAX_H2B_DENV_ZIKV.zarr + +native_delta_t_min: 120 +hpi_start: 5.0 +native_t: 11 + +wells: + B/2: + condition: mock + gene_channel_map: + "raw mCherry EX561 EM600-37": caax + "raw Cy5 EX639 EM698-70": h2b + B/3: + condition: DENV + moi: 5 + gene_channel_map: + "raw mCherry EX561 EM600-37": caax + "raw Cy5 EX639 EM698-70": h2b + B/4: + condition: ZIKV + moi: 5 + gene_channel_map: + "raw mCherry EX561 EM600-37": caax + "raw Cy5 EX639 EM698-70": h2b diff --git a/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_10_29_A549_TOMM20_ZIKV_DENV.yaml b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_10_29_A549_TOMM20_ZIKV_DENV.yaml new file mode 100644 index 000000000..34acd53b9 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_10_29_A549_TOMM20_ZIKV_DENV.yaml @@ -0,0 +1,26 @@ +# A549 mantis splits — 2024_10_29_A549_TOMM20_ZIKV_DENV +# +# Train-only plate per plan (test: []). +# Positions = wells kept in platemap ∩ zarr positions. Some zarr FOVs (e.g. +# B/4/002000, C/4/001001) are absent from the zarr and therefore excluded. + +experiment: 2024_10_29_A549_TOMM20_ZIKV_DENV +targets: + tomm20: + train: + - B/3/000000 + - B/3/001000 + - B/3/001001 + - B/3/002000 + - B/3/002001 + - B/4/000000 + - C/3/000000 + - C/3/001000 + - C/3/001001 + - C/3/002001 + - C/4/000000 + - C/4/000001 + - C/4/001000 + - C/4/002000 + - C/4/002001 + test: [] diff --git a/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_10_31_A549_SEC61_ZIKV_DENV.yaml b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_10_31_A549_SEC61_ZIKV_DENV.yaml new file mode 100644 index 000000000..86fe797d2 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_10_31_A549_SEC61_ZIKV_DENV.yaml @@ -0,0 +1,33 @@ +# A549 mantis splits — 2024_10_31_A549_SEC61_ZIKV_DENV +# +# Per plan: 4 DENV + 0 ZIKV test picks for this plate. +# Deterministic rule: within each (well, marker, condition) group, sort +# positions lexicographically and take the first N for test. +# +# Available positions after Airtable ∩ zarr: +# C/2 (ZIKV, 6): all → train (plan says 0 ZIKV test) +# C/4 (DENV, 6): first 4 → test, remaining 2 → train + +experiment: 2024_10_31_A549_SEC61_ZIKV_DENV +targets: + sec61b: + train: + - C/2/000000 + - C/2/000001 + - C/2/001000 + - C/2/001001 + - C/2/002000 + - C/2/002001 + - C/3/000000 + - C/3/000001 + - C/3/001000 + - C/3/001001 + - C/3/002000 + - C/3/002001 + - C/4/002000 + - C/4/002001 + test: + - C/4/000000 + - C/4/000001 + - C/4/001000 + - C/4/001001 diff --git a/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_11_05_A549_TOMM20_ZIKV_DENV.yaml b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_11_05_A549_TOMM20_ZIKV_DENV.yaml new file mode 100644 index 000000000..a7fc08fe9 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_11_05_A549_TOMM20_ZIKV_DENV.yaml @@ -0,0 +1,29 @@ +# A549 mantis splits — 2024_11_05_A549_TOMM20_ZIKV_DENV +# +# Plan: 3 mock + 4 DENV test. +# Available positions after Airtable ∩ zarr: +# B/4 (mock, 6) +# C/4 (DENV, 4) — C/4/000000 and C/4/000001 missing from zarr +# Rule: lexicographic sort, take first N for test. + +experiment: 2024_11_05_A549_TOMM20_ZIKV_DENV +targets: + tomm20: + train: + - B/3/000001 + - B/3/001000 + - B/3/002001 + - B/4/001001 + - C/3/000000 + - C/3/001000 + - C/3/001001 + - C/3/002000 + - C/3/002001 + test: + - B/4/000000 + - B/4/000001 + - B/4/001000 + - C/4/001000 + - C/4/001001 + - C/4/002000 + - C/4/002001 diff --git a/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_11_07_A549_SEC61_DENV.yaml b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_11_07_A549_SEC61_DENV.yaml new file mode 100644 index 000000000..0c820a7a0 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_11_07_A549_SEC61_DENV.yaml @@ -0,0 +1,30 @@ +# A549 mantis splits — 2024_11_07_A549_SEC61_DENV +# +# Positions listed here passed biological QC (Airtable ∩ dynacell zarr). +# Any FOV not in this file is excluded from both train and test. +# +# Per A549_MANTIS_PLAN.md test-set proposal: +# SEC61B mock: 4 test FOVs from 11_07 (of 8 mock available) +# SEC61B DENV: 8 test FOVs from 11_07 (all 8 DENV available) + +experiment: 2024_11_07_A549_SEC61_DENV +targets: + sec61b: + train: + - B/1/001000 + - B/1/001001 + - B/3/001000 + - B/3/001001 + test: + - B/1/000000 + - B/1/000001 + - B/3/000000 + - B/3/000001 + - B/2/000000 + - B/2/000001 + - B/2/001000 + - B/2/001001 + - C/2/000000 + - C/2/000001 + - C/2/001000 + - C/2/001001 diff --git a/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_11_21_A549_TOMM20_DENV.yaml b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_11_21_A549_TOMM20_DENV.yaml new file mode 100644 index 000000000..23cd35cf7 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2024_11_21_A549_TOMM20_DENV.yaml @@ -0,0 +1,25 @@ +# A549 mantis splits — 2024_11_21_A549_TOMM20_DENV +# +# Plan: 3 mock + 8 DENV test (all DENV → test, same pattern as 2024_11_07). +# Available positions after Airtable ∩ zarr (16 total, full match): +# B/1 (mock, 4), B/3 (mock, 4) → 8 mock +# B/2 (DENV, 4), C/2 (DENV, 4) → 8 DENV +# Rule: lexicographic sort across mock FOVs, take first 3 for test. + +experiment: 2024_11_21_A549_TOMM20_DENV +targets: + tomm20: + train: + - B/1/001001 + test: + - B/1/000000 + - B/1/000001 + - B/1/001000 + - B/2/000000 + - B/2/000001 + - B/2/001000 + - B/2/001001 + - C/2/000000 + - C/2/000001 + - C/2/001000 + - C/2/001001 diff --git a/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV.yaml b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV.yaml new file mode 100644 index 000000000..8676f3764 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV.yaml @@ -0,0 +1,40 @@ +# A549 mantis splits — 2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV +# +# Plan: SEC61B 4 mock + 6 ZIKV test; TOMM20 3 mock + 6 ZIKV test. +# G3BP1 wells (C/1, C/2) are omitted from the platemap and therefore absent +# from splits entirely. +# +# Available per target (Airtable ∩ zarr, full 6 FOV coverage each well): +# SEC61B: A/1 (mock, 6), A/2 (ZIKV, 6) → all 6 ZIKV to test, first 4 mock to test. +# TOMM20: B/1 (mock, 6), B/2 (ZIKV, 6) → all 6 ZIKV to test, first 3 mock to test. + +experiment: 2025_07_24_A549_SEC61_TOMM20_G3BP1_ZIKV +targets: + sec61b: + train: + - A/1/002000 + - A/1/002001 + test: + - A/1/000000 + - A/1/000001 + - A/1/001000 + - A/1/001001 + - A/2/000000 + - A/2/000001 + - A/2/001000 + - A/2/001001 + - A/2/002000 + - A/2/002001 + tomm20: + train: + - B/1/001001 + test: + - B/1/000000 + - B/1/000001 + - B/1/001000 + - B/2/000000 + - B/2/000001 + - B/2/001000 + - B/2/001001 + - B/2/002000 + - B/2/002001 diff --git a/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2025_08_26_A549_SEC61_TOMM20_ZIKV.yaml b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2025_08_26_A549_SEC61_TOMM20_ZIKV.yaml new file mode 100644 index 000000000..8cd78ef9d --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2025_08_26_A549_SEC61_TOMM20_ZIKV.yaml @@ -0,0 +1,47 @@ +# A549 mantis splits — 2025_08_26_A549_SEC61_TOMM20_ZIKV +# +# Plan: SEC61B 4 mock + 6 ZIKV test; TOMM20 3 mock + 6 ZIKV test. +# Available per target (Airtable ∩ zarr, full 9 FOV coverage each well): +# SEC61B: A/1 (mock, 9), B/1 (ZIKV, 9) +# TOMM20: A/2 (mock, 9), B/2 (ZIKV, 9) +# Rule: lexicographic sort within each well, take first N for test. + +experiment: 2025_08_26_A549_SEC61_TOMM20_ZIKV +targets: + sec61b: + train: + - A/1/001001 + - A/1/001002 + - A/1/002000 + - A/1/002001 + - A/1/002002 + - B/1/002000 + - B/1/002001 + - B/1/002002 + test: + - A/1/000000 + - A/1/000001 + - A/1/000002 + - A/1/001000 + - B/1/000000 + - B/1/000001 + - B/1/000002 + - B/1/001000 + - B/1/001001 + - B/1/001002 + tomm20: + train: + - A/2/001000 + - B/2/002000 + - B/2/002001 + - B/2/002002 + test: + - A/2/000000 + - A/2/000001 + - A/2/000002 + - B/2/000000 + - B/2/000001 + - B/2/000002 + - B/2/001000 + - B/2/001001 + - B/2/001002 diff --git a/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2026_03_26_A549_CAAX_H2B_DENV_ZIKV.yaml b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2026_03_26_A549_CAAX_H2B_DENV_ZIKV.yaml new file mode 100644 index 000000000..44ae1dc92 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/datasets/a549-mantis/authoring/splits/2026_03_26_A549_CAAX_H2B_DENV_ZIKV.yaml @@ -0,0 +1,154 @@ +# A549 mantis splits — 2026_03_26_A549_CAAX_H2B_DENV_ZIKV +# +# Spatial 4×3 lattice for test (rows {0,3,5,8} × cols {1,4,7}) → +# 12 FOVs/well × 3 wells = 36 test FOVs. Same FOV lattice for both +# h2b and caax (co-imaged on the same positions). Train is the +# remaining FOVs (68 + 69 + 69 = 206). +# +# DEVIATION FROM v1 PRACTICE: Airtable refresh 2026-04-26 returned +# 3 well-level H2B rows and zero FOV-level rows for this plate. +# v1 splits filter to FOVs that pass FOV-level biology QC in +# Airtable; for 03_26 we ship every co-imaged FOV in the source +# zarr because no per-FOV QC labels exist yet. If the Airtable +# pool gets backfilled, regenerate this file and rerun assembly. + +experiment: 2026_03_26_A549_CAAX_H2B_DENV_ZIKV +targets: + h2b: + train: + - B/2/000002 + - B/2/000003 + - B/2/000005 + - B/2/000006 + - B/2/000008 + - B/2/001000 + - B/2/001001 + - B/2/001002 + - B/2/001003 + - B/2/001004 + - B/2/001005 + - B/2/001006 + - B/3/000000 + - B/3/000002 + - B/3/000003 + - B/3/000005 + - B/3/000006 + - B/3/000008 + - B/4/000000 + - B/4/000002 + - B/4/000003 + - B/4/000005 + - B/4/000006 + - B/4/000008 + - B/4/001000 + - B/4/001001 + - B/4/001002 + - B/4/001003 + - B/4/001004 + - B/4/001005 + test: + - B/2/000001 + - B/2/000004 + - B/2/000007 + - B/2/003001 + - B/2/003004 + - B/2/003007 + - B/2/005001 + - B/2/005004 + - B/2/005007 + - B/2/008001 + - B/2/008004 + - B/2/008007 + - B/3/000001 + - B/3/000004 + - B/3/000007 + - B/3/003001 + - B/3/003004 + - B/3/003007 + - B/3/005001 + - B/3/005004 + - B/3/005007 + - B/3/008001 + - B/3/008004 + - B/3/008007 + - B/4/000001 + - B/4/000004 + - B/4/000007 + - B/4/003001 + - B/4/003004 + - B/4/003007 + - B/4/005001 + - B/4/005004 + - B/4/005007 + - B/4/008001 + - B/4/008004 + - B/4/008007 + caax: + train: + - B/2/000002 + - B/2/000003 + - B/2/000005 + - B/2/000006 + - B/2/000008 + - B/2/001000 + - B/2/001001 + - B/2/001002 + - B/2/001003 + - B/2/001004 + - B/2/001005 + - B/2/001006 + - B/3/000000 + - B/3/000002 + - B/3/000003 + - B/3/000005 + - B/3/000006 + - B/3/000008 + - B/4/000000 + - B/4/000002 + - B/4/000003 + - B/4/000005 + - B/4/000006 + - B/4/000008 + - B/4/001000 + - B/4/001001 + - B/4/001002 + - B/4/001003 + - B/4/001004 + - B/4/001005 + test: + - B/2/000001 + - B/2/000004 + - B/2/000007 + - B/2/003001 + - B/2/003004 + - B/2/003007 + - B/2/005001 + - B/2/005004 + - B/2/005007 + - B/2/008001 + - B/2/008004 + - B/2/008007 + - B/3/000001 + - B/3/000004 + - B/3/000007 + - B/3/003001 + - B/3/003004 + - B/3/003007 + - B/3/005001 + - B/3/005004 + - B/3/005007 + - B/3/008001 + - B/3/008004 + - B/3/008007 + - B/4/000001 + - B/4/000004 + - B/4/000007 + - B/4/003001 + - B/4/003004 + - B/4/003007 + - B/4/005001 + - B/4/005004 + - B/4/005007 + - B/4/008001 + - B/4/008004 + - B/4/008007 diff --git a/applications/dynacell/src/dynacell/_configs/preprocess/dynacell/a549_assemble_pool.yaml b/applications/dynacell/src/dynacell/_configs/preprocess/dynacell/a549_assemble_pool.yaml new file mode 100644 index 000000000..33b81fa7b --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/preprocess/dynacell/a549_assemble_pool.yaml @@ -0,0 +1,106 @@ +# A549 mantis pool assembly. +# +# Consumed by `dynacell.preprocess.a549_mantis.assemble.assemble_pool`, +# which takes this file as its DictConfig (see its docstring for the key +# contract). There is no `dynacell preprocess assemble-pool` CLI; run it +# directly: +# cfg = load_preprocess_config(Path(".../a549_assemble_pool.yaml")) +# assemble_pool(cfg) +# +# Produces one HCS store per (target, condition, split) under +# //_.. Position naming is +# pool-internal: 0/0/fov0000, 0/0/fov0001, … with sequential indexing +# across all contributing plates. Plate provenance is in per-position +# zattrs and the colocated _.provenance.json sidecar. +# +# On the train side, also emits /train/_all.zarr — +# a directory zarr (not ozx) covering all conditions for one target. +# Used as the single-store training corpus for downstream models. + +# Targets and conditions to assemble. Subset OK; pools that no plate +# contributes to are logged as "skipped" with no error. `dual_nucl_memb` +# is the combined nucleus+membrane target: both v2 fluor genes (h2b + +# caax, co-imaged) merged into one [Phase3D, Brightfield, Nuclei, +# Membrane] pool. ER/mito (sec61b/tomm20) stay single-gene and emit BOTH +# raw Structure + Structure_deconvolved channels. +targets: [sec61b, tomm20, dual_nucl_memb] +conditions: [mock, ZIKV, DENV] + +# Optional plate restriction. Empty / null = every plate authored under +# authoring_root. Useful for dev runs that should hit a single plate. +plates: null + +# Source plate zarrs live under intracellular_dashboard and are read-only +# for this pipeline. The /2-assemble/ and /dynacell/ subdirs under each +# plate are the canonical upstream outputs — assembly never writes there +# (enforced by _check_output_safety). +plate_zarr_root: /hpc/projects/intracellular_dashboard/organelle_dynamics + +# Canonical output under the VS training tree. The corpus dir is ``mantis`` +# (was ``mantis_v1``, a misnomer — the corpus pools BOTH microscope +# generations: v1 ER/mito plates @0.1494 µm/px + the v2 nucleus/membrane +# plate @0.116 µm/px, resampled to 0.1494). ``mantis_v1``/``mantis_v2`` were +# only ever pitch labels, never separate corpora. Old stores stay at +# ``mantis_v1/`` as the byte-identity reference until this run is verified. +output_root: /hpc/projects/virtual_staining/training/dynacell/a549/mantis + +# Refuse to clobber an existing output. Set true on intentional re-runs. +overwrite: false + +# Per-plate (z, y, x) spacing is read from each source plate's NGFF +# metadata at assembly time (`_read_source_spacing` in assemble.py). +grid: + stride_h: 2.0 + window: [5.0, 23.0] + tail_tol_h: 1.5 + +# Per-condition store format (one of ozx, zarr). Set to zarr so the +# INTERNAL per-condition test store is a directory zarr carrying all +# channels (incl. Structure_deconvolved). The raw-only publication .ozx +# is derived from it via emit_raw_only_ozx below. +condition_format: zarr + +# Train-side _all store format. Default zarr — a directory store +# (not ozx) so training pipelines that expect appendability can use it +# directly. Setting this to ozx is allowed but uncommon. +pool_all_format: zarr + +# Whether to emit _all on the train side in addition to the per- +# condition stores. Set false to skip the pooled training store. +emit_train_pool_all: true + +# Also derive a colocated raw-only _.ozx next to each +# internal directory-zarr per-condition store, dropping every +# *_deconvolved channel. This is the publication artifact (AWS Open Data +# mirror). Requires condition_format: zarr. Targets without a deconvolved +# channel (dual_nucl_memb → nuclei/membrane are raw-only) have nothing to +# drop, so the internal store is packed as-is — the .ozx mirror is still +# emitted for every target. +emit_raw_only_ozx: true + +# Cap the number of assembled timepoints (after the 2-h hpi grid). null = +# no cap. T=10 covers the full 5..23 hpi grid; plates with shorter native +# runs (e.g. 2024_10_29 → 5 frames, 2024_10_31 → 7) emit fewer regardless +# and are unaffected. The cap exists so future plates with longer +# native_t don't silently inflate the train side beyond design. +t_cap: 10 + +# Per-split center-crop applied AFTER any pixel-size resample. Y, X in +# pixels of the post-resample block. Both splits now ship at 640x960 +# (≈ 95.6 × 143.4 µm at 0.1494 µm/px): test is UNCROPPED from the old +# 512x512 to the same 640x960 window as train so eval sees the full FOV. +# Set null on either side to skip cropping. +train_center_crop_yx: [640, 960] +test_center_crop_yx: [640, 960] + +# Per-split target lateral pixel size (µm/px). When non-null and finer +# than the source NGFF spacing, the (Y, X) plane is resampled to this +# pixel size BEFORE center-crop so all plates land at a uniform size. +# 0.1494 collapses mantis_v2 (0.116, the nuc/mem plate) onto v1's pitch; +# v1 ER/mito plates already at 0.1494 are no-ops. Both splits now resample +# so the uncropped 640x960 test window is uniform across microscopes. +train_target_yx_pixel_size_um: 0.1494 +test_target_yx_pixel_size_um: 0.1494 + +# Splits to write. Default builds both train and test in one run. +splits: [train, test] diff --git a/applications/dynacell/src/dynacell/_configs/preprocess/dynacell/a549_pack_ozx.yaml b/applications/dynacell/src/dynacell/_configs/preprocess/dynacell/a549_pack_ozx.yaml new file mode 100644 index 000000000..533200b05 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/preprocess/dynacell/a549_pack_ozx.yaml @@ -0,0 +1,26 @@ +# OZX packaging reference defaults for `dynacell distribute pack` / `sample`. +# +# The CLI does not load this file: every value is passed as a flag. The +# equivalent invocations are +# dynacell distribute pack --output-root [--overwrite] +# dynacell distribute sample --output-root \ +# --max-fovs --max-t +# with a registered name (e.g. a549-mantis-2024_11_07). Keep the +# values below in sync with what was actually run so the release layout stays +# reproducible. +# +# Output layout: +# ///.ozx +# //MANIFEST.json +# +# Sample mode packs the reviewer subset (NeurIPS <4 GB requirement). + +output_root: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1_ozx + +# Refuse to overwrite existing OZX archives by default; pass --overwrite +# on the CLI to replace them after a re-assembly. +overwrite: false + +sample: + fov_limit: 5 + t_limit: 1 diff --git a/applications/dynacell/src/dynacell/_configs/preprocess/dynacell/nuclei_membrane_selection.yaml b/applications/dynacell/src/dynacell/_configs/preprocess/dynacell/nuclei_membrane_selection.yaml new file mode 100644 index 000000000..0cccc5156 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/preprocess/dynacell/nuclei_membrane_selection.yaml @@ -0,0 +1,23 @@ +# Shares structure with organelle_selection.yaml but different channels. +na_det: 1.25 +lambda_illumination: 0.405 +pixel_size_xy: 0.108 + +depth: 44 +random_seed: 42 +num_train: 500 +num_test: 100 + +input_data_directory: /hpc/projects/virtual_staining/training/dynacell/ipsc +output_save_directory: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4 +# Store-name stems, not WorkflowId tokens: each id selects +# `/_fluor.zarr` (4_fluor.zarr, 4_1_fluor.zarr, +# 4_2_fluor.zarr). `is_target_workflow` expects the dotted form ("4.1") +# parsed from per-FOV `[Pipeline 4.1]` metadata; do not pass these to it. +pipeline_ids: ["4", "4_1", "4_2"] +output_channel_names: ["Brightfield", "Nuclei", "Membrane", "Phase3D"] + +output_chunks: [1, 1, 8, 512, 512] +shards_ratio: [2, 1, 8, 8, 8] +zarr_version: "0.5" +zarr_layout: hcs diff --git a/applications/dynacell/src/dynacell/_configs/preprocess/dynacell/organelle_selection.yaml b/applications/dynacell/src/dynacell/_configs/preprocess/dynacell/organelle_selection.yaml new file mode 100644 index 000000000..dc1753e0e --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/preprocess/dynacell/organelle_selection.yaml @@ -0,0 +1,29 @@ +# Optics (for focus detection via waveorder). +na_det: 1.25 +lambda_illumination: 0.405 +pixel_size_xy: 0.108 + +# Selection. +target_organelles: ["SEC61B", "TOMM20"] +depth: 44 +random_seed: 42 + +# Split sizes. +num_train: 500 +num_test: 100 + +# I/O. +input_data_directory: /hpc/projects/virtual_staining/training/dynacell/ipsc +output_save_directory: /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4 +# Store-name stems, not WorkflowId tokens: each id selects +# `/_fluor.zarr` (4_fluor.zarr, 4_1_fluor.zarr, +# 4_2_fluor.zarr). `is_target_workflow` expects the dotted form ("4.1") +# parsed from per-FOV `[Pipeline 4.1]` metadata; do not pass these to it. +pipeline_ids: ["4", "4_1", "4_2"] +output_channel_names: ["Brightfield", "Nuclei", "Membrane", "Structure", "Phase3D"] + +# Zarr output. +output_chunks: [1, 1, 8, 512, 512] +shards_ratio: [2, 1, 8, 8, 8] +zarr_version: "0.5" +zarr_layout: hcs diff --git a/applications/dynacell/src/dynacell/_configs/preprocess/dynacell/segmentation.yaml b/applications/dynacell/src/dynacell/_configs/preprocess/dynacell/segmentation.yaml new file mode 100644 index 000000000..edb2b7778 --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/preprocess/dynacell/segmentation.yaml @@ -0,0 +1,24 @@ +# Cellpose reference defaults for +# `dynacell.preprocess.segmentation.run_cellpose_segmentation`. +# +# There is no `dynacell preprocess segment` CLI; call the function directly. +# Keys mirror its keyword arguments, so after filling the `???` I/O fields: +# cfg = load_preprocess_config(Path(".../segmentation.yaml")) +# run_cellpose_segmentation(**OmegaConf.to_container(cfg)) +data_dir: ??? +save_dir: ??? +input_channel_names: ??? + +use_gpu: true +batch_size: 32 + +# 3D-specific (do_3d: false max-projects to 2D instead) +do_3d: true +z_axis: 1 +flow_3d_smooth: 10 + +# Output zarr settings +output_channel_names: ["segmentation"] +output_dtype: uint8 +zarr_layout: hcs +zarr_version: "0.5" diff --git a/applications/dynacell/src/dynacell/_configs/preprocess/update_zarr.yaml b/applications/dynacell/src/dynacell/_configs/preprocess/update_zarr.yaml new file mode 100644 index 000000000..c825bc6fd --- /dev/null +++ b/applications/dynacell/src/dynacell/_configs/preprocess/update_zarr.yaml @@ -0,0 +1,6 @@ +input_zarr: ??? +output_zarr: ??? + +chunks: [1, 1, 8, 64, 64] +shards_ratio: [2, 1, 8, 8, 8] +zarr_version: "0.5" diff --git a/applications/dynacell/src/dynacell/_manifests/README.md b/applications/dynacell/src/dynacell/_manifests/README.md new file mode 100644 index 000000000..2c625adad --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/README.md @@ -0,0 +1,24 @@ +# dynacell._manifests + +Bundled dataset registry — the **default** manifest roots the [resolver](../data/README.md) discovers via the +`dynacell.manifest_roots` entry point (declared in `pyproject.toml`), so path resolution works out-of-the-box +on any clone. Override at runtime with `DYNACELL_MANIFEST_ROOTS=/path/to/other/registry`. + +**This directory is the source of truth for dataset manifests.** There is no longer a mirrored copy to stay in +sync with: `dynacell-paper` consumed the migrated preprocessing/registry code in its Phase-13 consolidation and +deleted its own `_configs/datasets/` tree, so authoring and content both live here. Edit these YAMLs directly. + +## Layout + +Each `/` holds a `manifest.yaml` (channels, voxel `spacing`, and per-target `stores`: +train/test/cell_segmentation/gt_cache_dir) plus a `splits/` folder of train/val/test position lists. + +- `aics-hipsc/` — WTC-11 hiPSC confocal (Allen Institute), all four targets (`nucleus`, `membrane`, `sec61b`, + `tomm20`); one split file per target. +- `a549-mantis--/` — the A549 Mantis light-sheet registry, one manifest per + `marker ∈ {caax, h2b, sec61b, tomm20}` × `condition ∈ {mock, denv, zikv}` (12 folders). CAAX = membrane, + H2B = nucleus. + +## Navigation + +- Up: [dynacell](../README.md) diff --git a/applications/dynacell/src/dynacell/_manifests/__init__.py b/applications/dynacell/src/dynacell/_manifests/__init__.py index dc4a24739..6fc06975d 100644 --- a/applications/dynacell/src/dynacell/_manifests/__init__.py +++ b/applications/dynacell/src/dynacell/_manifests/__init__.py @@ -1,14 +1,15 @@ """Bundled dataset manifests — the default registry for the DynaCell resolver. -This package ships canonical manifest YAMLs (mirrored from -``dynacell-paper/_configs/datasets/``) so the resolver works out-of-the-box -on any clone. Auto-discovered via the ``dynacell.manifest_roots`` entry -point declared in ``applications/dynacell/pyproject.toml``. +This package ships the canonical manifest YAMLs so the resolver works +out-of-the-box on any clone. Auto-discovered via the +``dynacell.manifest_roots`` entry point declared in +``applications/dynacell/pyproject.toml``. -VisCy is the source of truth for manifest *content* (this directory). -``dynacell-paper`` is the source of truth for manifest *authoring* — when -a new dataset is preprocessed there, the change is mirrored back here and -``tests/test_manifest_sync.py`` enforces the parity. +**This package is the source of truth for dataset manifests** — both +content and authoring. ``dynacell-paper`` deleted its own +``_configs/datasets/`` tree when it consumed the migrated preprocessing +code (Phase 13), so there is no second copy and no parity to enforce. +Edit these YAMLs directly. Override at runtime with ``DYNACELL_MANIFEST_ROOTS=/path/to/other/registry`` (env var) or by passing ``cli_roots=`` to ``discover_manifest_roots``. diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-denv-lite/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-denv-lite/manifest.yaml new file mode 100644 index 000000000..f18a32133 --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-denv-lite/manifest.yaml @@ -0,0 +1,26 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-caax-denv/manifest.yaml. Do not edit; regenerate. +name: a549-mantis-caax-denv-lite +version: '1' +description: 'DynaCell-lite test subset of a549-mantis-caax-denv, built by build_temporal_subset_zarr.py and registered by + generate_lite_benchmark_configs.py. Test-only: no train store.' +cell_type: A549 +imaging_modality: mantis-lightsheet +spacing: + z: 0.174 + y: 0.1494 + x: 0.1494 +channels: + source: Phase3D + auxiliary: + - Brightfield +targets: + caax: + gene: CAAX + organelle: membrane + display_name: Membrane (CAAX) + target_channel: Membrane + stores: + test: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/dual_nucl_memb_DENV.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/dual_nucl_memb_DENV_seg_cleaned.zarr + gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache/caax_denv + splits: splits/caax_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-denv-lite/splits/caax_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-denv-lite/splits/caax_train_test.yaml new file mode 100644 index 000000000..4a9c47763 --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-denv-lite/splits/caax_train_test.yaml @@ -0,0 +1,27 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-caax-denv/manifest.yaml. Do not edit; regenerate. +split_version: '1' +random_seed: 0 +source_stores: +- /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr +selection_criteria: + lite_of: a549-mantis-caax-denv + timepoints: spread n_timepoints=5 per position; the source frames of each position are in the store's .provenance.json sidecar + positions: all source positions +train: + count: 0 + fovs: [] +test: + count: 12 + fovs: + - 0/0/fov0000 + - 0/0/fov0001 + - 0/0/fov0002 + - 0/0/fov0003 + - 0/0/fov0004 + - 0/0/fov0005 + - 0/0/fov0006 + - 0/0/fov0007 + - 0/0/fov0008 + - 0/0/fov0009 + - 0/0/fov0010 + - 0/0/fov0011 diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-denv/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-denv/manifest.yaml index 13e751ba2..e27bc9893 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-denv/manifest.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-denv/manifest.yaml @@ -20,8 +20,8 @@ targets: display_name: Membrane (CAAX) target_channel: Membrane stores: - train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/CAAX_DENV.ozx - test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/CAAX_DENV.ozx - cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/CAAX_DENV_seg_cleaned.zarr + train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all.zarr + test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV_seg_cleaned.zarr gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache/caax_denv splits: splits/caax_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-denv/splits/caax_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-denv/splits/caax_train_test.yaml index 7eef68a46..49e9eeab4 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-denv/splits/caax_train_test.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-denv/splits/caax_train_test.yaml @@ -8,12 +8,12 @@ selection_criteria: train: count: 6 fovs: - - 0/0/fov0000 - - 0/0/fov0001 - - 0/0/fov0002 - - 0/0/fov0003 - - 0/0/fov0004 - - 0/0/fov0005 + - 0/0/fov0012 + - 0/0/fov0013 + - 0/0/fov0014 + - 0/0/fov0015 + - 0/0/fov0016 + - 0/0/fov0017 test: count: 12 fovs: diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-mock-lite/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-mock-lite/manifest.yaml new file mode 100644 index 000000000..b9705d52d --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-mock-lite/manifest.yaml @@ -0,0 +1,26 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-caax-mock/manifest.yaml. Do not edit; regenerate. +name: a549-mantis-caax-mock-lite +version: '1' +description: 'DynaCell-lite test subset of a549-mantis-caax-mock, built by build_temporal_subset_zarr.py and registered by + generate_lite_benchmark_configs.py. Test-only: no train store.' +cell_type: A549 +imaging_modality: mantis-lightsheet +spacing: + z: 0.174 + y: 0.1494 + x: 0.1494 +channels: + source: Phase3D + auxiliary: + - Brightfield +targets: + caax: + gene: CAAX + organelle: membrane + display_name: Membrane (CAAX) + target_channel: Membrane + stores: + test: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/dual_nucl_memb_mock.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/dual_nucl_memb_mock_seg_cleaned.zarr + gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache/caax_mock + splits: splits/caax_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-mock-lite/splits/caax_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-mock-lite/splits/caax_train_test.yaml new file mode 100644 index 000000000..72fc36201 --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-mock-lite/splits/caax_train_test.yaml @@ -0,0 +1,27 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-caax-mock/manifest.yaml. Do not edit; regenerate. +split_version: '1' +random_seed: 0 +source_stores: +- /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr +selection_criteria: + lite_of: a549-mantis-caax-mock + timepoints: spread n_timepoints=5 per position; the source frames of each position are in the store's .provenance.json sidecar + positions: all source positions +train: + count: 0 + fovs: [] +test: + count: 12 + fovs: + - 0/0/fov0000 + - 0/0/fov0001 + - 0/0/fov0002 + - 0/0/fov0003 + - 0/0/fov0004 + - 0/0/fov0005 + - 0/0/fov0006 + - 0/0/fov0007 + - 0/0/fov0008 + - 0/0/fov0009 + - 0/0/fov0010 + - 0/0/fov0011 diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-mock/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-mock/manifest.yaml index 1c2d99d28..fe761470a 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-mock/manifest.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-mock/manifest.yaml @@ -20,8 +20,8 @@ targets: display_name: Membrane (CAAX) target_channel: Membrane stores: - train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/CAAX_mock.ozx - test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/CAAX_mock.ozx - cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/CAAX_mock_seg_cleaned.zarr + train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all.zarr + test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock_seg_cleaned.zarr gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache/caax_mock splits: splits/caax_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-zikv-lite/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-zikv-lite/manifest.yaml new file mode 100644 index 000000000..2553c65de --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-zikv-lite/manifest.yaml @@ -0,0 +1,26 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-caax-zikv/manifest.yaml. Do not edit; regenerate. +name: a549-mantis-caax-zikv-lite +version: '1' +description: 'DynaCell-lite test subset of a549-mantis-caax-zikv, built by build_temporal_subset_zarr.py and registered by + generate_lite_benchmark_configs.py. Test-only: no train store.' +cell_type: A549 +imaging_modality: mantis-lightsheet +spacing: + z: 0.174 + y: 0.1494 + x: 0.1494 +channels: + source: Phase3D + auxiliary: + - Brightfield +targets: + caax: + gene: CAAX + organelle: membrane + display_name: Membrane (CAAX) + target_channel: Membrane + stores: + test: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/dual_nucl_memb_ZIKV_seg_cleaned.zarr + gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache/caax_zikv + splits: splits/caax_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-zikv-lite/splits/caax_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-zikv-lite/splits/caax_train_test.yaml new file mode 100644 index 000000000..d35094cf9 --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-zikv-lite/splits/caax_train_test.yaml @@ -0,0 +1,27 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-caax-zikv/manifest.yaml. Do not edit; regenerate. +split_version: '1' +random_seed: 0 +source_stores: +- /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr +selection_criteria: + lite_of: a549-mantis-caax-zikv + timepoints: spread n_timepoints=5 per position; the source frames of each position are in the store's .provenance.json sidecar + positions: all source positions +train: + count: 0 + fovs: [] +test: + count: 12 + fovs: + - 0/0/fov0000 + - 0/0/fov0001 + - 0/0/fov0002 + - 0/0/fov0003 + - 0/0/fov0004 + - 0/0/fov0005 + - 0/0/fov0006 + - 0/0/fov0007 + - 0/0/fov0008 + - 0/0/fov0009 + - 0/0/fov0010 + - 0/0/fov0011 diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-zikv/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-zikv/manifest.yaml index aee5f9968..612693ab8 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-zikv/manifest.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-zikv/manifest.yaml @@ -20,8 +20,8 @@ targets: display_name: Membrane (CAAX) target_channel: Membrane stores: - train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/CAAX_ZIKV.ozx - test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/CAAX_ZIKV.ozx - cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/CAAX_ZIKV_seg_cleaned.zarr + train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all.zarr + test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV_seg_cleaned.zarr gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache/caax_zikv splits: splits/caax_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-zikv/splits/caax_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-zikv/splits/caax_train_test.yaml index 68c02e1cc..2c612aed0 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-zikv/splits/caax_train_test.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-caax-zikv/splits/caax_train_test.yaml @@ -8,18 +8,18 @@ selection_criteria: train: count: 12 fovs: - - 0/0/fov0000 - - 0/0/fov0001 - - 0/0/fov0002 - - 0/0/fov0003 - - 0/0/fov0004 - - 0/0/fov0005 - - 0/0/fov0006 - - 0/0/fov0007 - - 0/0/fov0008 - - 0/0/fov0009 - - 0/0/fov0010 - - 0/0/fov0011 + - 0/0/fov0018 + - 0/0/fov0019 + - 0/0/fov0020 + - 0/0/fov0021 + - 0/0/fov0022 + - 0/0/fov0023 + - 0/0/fov0024 + - 0/0/fov0025 + - 0/0/fov0026 + - 0/0/fov0027 + - 0/0/fov0028 + - 0/0/fov0029 test: count: 12 fovs: diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-denv-lite/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-denv-lite/manifest.yaml new file mode 100644 index 000000000..3cc6b85ab --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-denv-lite/manifest.yaml @@ -0,0 +1,26 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-h2b-denv/manifest.yaml. Do not edit; regenerate. +name: a549-mantis-h2b-denv-lite +version: '1' +description: 'DynaCell-lite test subset of a549-mantis-h2b-denv, built by build_temporal_subset_zarr.py and registered by + generate_lite_benchmark_configs.py. Test-only: no train store.' +cell_type: A549 +imaging_modality: mantis-lightsheet +spacing: + z: 0.174 + y: 0.1494 + x: 0.1494 +channels: + source: Phase3D + auxiliary: + - Brightfield +targets: + h2b: + gene: H2B + organelle: nuclei + display_name: Nuclei (H2B) + target_channel: Nuclei + stores: + test: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/dual_nucl_memb_DENV.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/dual_nucl_memb_DENV_seg_cleaned.zarr + gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache/h2b_denv + splits: splits/h2b_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-denv-lite/splits/h2b_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-denv-lite/splits/h2b_train_test.yaml new file mode 100644 index 000000000..49a91930c --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-denv-lite/splits/h2b_train_test.yaml @@ -0,0 +1,27 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-h2b-denv/manifest.yaml. Do not edit; regenerate. +split_version: '1' +random_seed: 0 +source_stores: +- /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr +selection_criteria: + lite_of: a549-mantis-h2b-denv + timepoints: spread n_timepoints=5 per position; the source frames of each position are in the store's .provenance.json sidecar + positions: all source positions +train: + count: 0 + fovs: [] +test: + count: 12 + fovs: + - 0/0/fov0000 + - 0/0/fov0001 + - 0/0/fov0002 + - 0/0/fov0003 + - 0/0/fov0004 + - 0/0/fov0005 + - 0/0/fov0006 + - 0/0/fov0007 + - 0/0/fov0008 + - 0/0/fov0009 + - 0/0/fov0010 + - 0/0/fov0011 diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-denv/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-denv/manifest.yaml index 3a9798989..861e8933f 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-denv/manifest.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-denv/manifest.yaml @@ -20,8 +20,8 @@ targets: display_name: Nuclei (H2B) target_channel: Nuclei stores: - train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/H2B_DENV.ozx - test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV.ozx - cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_DENV_seg_cleaned.zarr + train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all.zarr + test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_DENV_seg_cleaned.zarr gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache/h2b_denv splits: splits/h2b_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-denv/splits/h2b_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-denv/splits/h2b_train_test.yaml index 6ecba4b06..a365d0b76 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-denv/splits/h2b_train_test.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-denv/splits/h2b_train_test.yaml @@ -8,12 +8,12 @@ selection_criteria: train: count: 6 fovs: - - 0/0/fov0000 - - 0/0/fov0001 - - 0/0/fov0002 - - 0/0/fov0003 - - 0/0/fov0004 - - 0/0/fov0005 + - 0/0/fov0012 + - 0/0/fov0013 + - 0/0/fov0014 + - 0/0/fov0015 + - 0/0/fov0016 + - 0/0/fov0017 test: count: 12 fovs: diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-mock-lite/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-mock-lite/manifest.yaml new file mode 100644 index 000000000..ed9a8deb7 --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-mock-lite/manifest.yaml @@ -0,0 +1,26 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-h2b-mock/manifest.yaml. Do not edit; regenerate. +name: a549-mantis-h2b-mock-lite +version: '1' +description: 'DynaCell-lite test subset of a549-mantis-h2b-mock, built by build_temporal_subset_zarr.py and registered by + generate_lite_benchmark_configs.py. Test-only: no train store.' +cell_type: A549 +imaging_modality: mantis-lightsheet +spacing: + z: 0.174 + y: 0.1494 + x: 0.1494 +channels: + source: Phase3D + auxiliary: + - Brightfield +targets: + h2b: + gene: H2B + organelle: nuclei + display_name: Nuclei (H2B) + target_channel: Nuclei + stores: + test: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/dual_nucl_memb_mock.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/dual_nucl_memb_mock_seg_cleaned.zarr + gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache/h2b_mock + splits: splits/h2b_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-mock-lite/splits/h2b_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-mock-lite/splits/h2b_train_test.yaml new file mode 100644 index 000000000..32167932b --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-mock-lite/splits/h2b_train_test.yaml @@ -0,0 +1,27 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-h2b-mock/manifest.yaml. Do not edit; regenerate. +split_version: '1' +random_seed: 0 +source_stores: +- /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr +selection_criteria: + lite_of: a549-mantis-h2b-mock + timepoints: spread n_timepoints=5 per position; the source frames of each position are in the store's .provenance.json sidecar + positions: all source positions +train: + count: 0 + fovs: [] +test: + count: 12 + fovs: + - 0/0/fov0000 + - 0/0/fov0001 + - 0/0/fov0002 + - 0/0/fov0003 + - 0/0/fov0004 + - 0/0/fov0005 + - 0/0/fov0006 + - 0/0/fov0007 + - 0/0/fov0008 + - 0/0/fov0009 + - 0/0/fov0010 + - 0/0/fov0011 diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-mock/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-mock/manifest.yaml index a501d4234..31c6c2394 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-mock/manifest.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-mock/manifest.yaml @@ -20,8 +20,8 @@ targets: display_name: Nuclei (H2B) target_channel: Nuclei stores: - train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/H2B_mock.ozx - test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock.ozx - cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_mock_seg_cleaned.zarr + train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all.zarr + test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_mock_seg_cleaned.zarr gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache/h2b_mock splits: splits/h2b_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-zikv-lite/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-zikv-lite/manifest.yaml new file mode 100644 index 000000000..4adf5c496 --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-zikv-lite/manifest.yaml @@ -0,0 +1,26 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-h2b-zikv/manifest.yaml. Do not edit; regenerate. +name: a549-mantis-h2b-zikv-lite +version: '1' +description: 'DynaCell-lite test subset of a549-mantis-h2b-zikv, built by build_temporal_subset_zarr.py and registered by + generate_lite_benchmark_configs.py. Test-only: no train store.' +cell_type: A549 +imaging_modality: mantis-lightsheet +spacing: + z: 0.174 + y: 0.1494 + x: 0.1494 +channels: + source: Phase3D + auxiliary: + - Brightfield +targets: + h2b: + gene: H2B + organelle: nuclei + display_name: Nuclei (H2B) + target_channel: Nuclei + stores: + test: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/dual_nucl_memb_ZIKV_seg_cleaned.zarr + gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache/h2b_zikv + splits: splits/h2b_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-zikv-lite/splits/h2b_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-zikv-lite/splits/h2b_train_test.yaml new file mode 100644 index 000000000..b1989d2f6 --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-zikv-lite/splits/h2b_train_test.yaml @@ -0,0 +1,27 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-h2b-zikv/manifest.yaml. Do not edit; regenerate. +split_version: '1' +random_seed: 0 +source_stores: +- /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr +selection_criteria: + lite_of: a549-mantis-h2b-zikv + timepoints: spread n_timepoints=5 per position; the source frames of each position are in the store's .provenance.json sidecar + positions: all source positions +train: + count: 0 + fovs: [] +test: + count: 12 + fovs: + - 0/0/fov0000 + - 0/0/fov0001 + - 0/0/fov0002 + - 0/0/fov0003 + - 0/0/fov0004 + - 0/0/fov0005 + - 0/0/fov0006 + - 0/0/fov0007 + - 0/0/fov0008 + - 0/0/fov0009 + - 0/0/fov0010 + - 0/0/fov0011 diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-zikv/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-zikv/manifest.yaml index a6d764aec..a301a227c 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-zikv/manifest.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-zikv/manifest.yaml @@ -20,8 +20,8 @@ targets: display_name: Nuclei (H2B) target_channel: Nuclei stores: - train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/H2B_ZIKV.ozx - test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV.ozx - cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/H2B_ZIKV_seg_cleaned.zarr + train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/dual_nucl_memb_all.zarr + test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/dual_nucl_memb_ZIKV_seg_cleaned.zarr gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache/h2b_zikv splits: splits/h2b_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-zikv/splits/h2b_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-zikv/splits/h2b_train_test.yaml index 99292f5dd..109eebf4a 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-zikv/splits/h2b_train_test.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-h2b-zikv/splits/h2b_train_test.yaml @@ -8,18 +8,18 @@ selection_criteria: train: count: 12 fovs: - - 0/0/fov0000 - - 0/0/fov0001 - - 0/0/fov0002 - - 0/0/fov0003 - - 0/0/fov0004 - - 0/0/fov0005 - - 0/0/fov0006 - - 0/0/fov0007 - - 0/0/fov0008 - - 0/0/fov0009 - - 0/0/fov0010 - - 0/0/fov0011 + - 0/0/fov0018 + - 0/0/fov0019 + - 0/0/fov0020 + - 0/0/fov0021 + - 0/0/fov0022 + - 0/0/fov0023 + - 0/0/fov0024 + - 0/0/fov0025 + - 0/0/fov0026 + - 0/0/fov0027 + - 0/0/fov0028 + - 0/0/fov0029 test: count: 12 fovs: diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-denv-lite/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-denv-lite/manifest.yaml new file mode 100644 index 000000000..a73c3bfb7 --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-denv-lite/manifest.yaml @@ -0,0 +1,26 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-sec61b-denv/manifest.yaml. Do not edit; regenerate. +name: a549-mantis-sec61b-denv-lite +version: '1' +description: 'DynaCell-lite test subset of a549-mantis-sec61b-denv, built by build_temporal_subset_zarr.py and registered + by generate_lite_benchmark_configs.py. Test-only: no train store.' +cell_type: A549 +imaging_modality: mantis-lightsheet +spacing: + z: 0.174 + y: 0.1494 + x: 0.1494 +channels: + source: Phase3D + auxiliary: + - Brightfield +targets: + sec61b: + gene: SEC61B + organelle: er + display_name: ER (Sec61b) + target_channel: Structure + stores: + test: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/SEC61B_DENV.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/SEC61B_DENV_seg_cleaned.zarr + gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache/sec61b_denv + splits: splits/sec61b_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-denv-lite/splits/sec61b_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-denv-lite/splits/sec61b_train_test.yaml new file mode 100644 index 000000000..33bbef6b4 --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-denv-lite/splits/sec61b_train_test.yaml @@ -0,0 +1,27 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-sec61b-denv/manifest.yaml. Do not edit; regenerate. +split_version: '1' +random_seed: 0 +source_stores: +- /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/SEC61B_DENV.zarr +selection_criteria: + lite_of: a549-mantis-sec61b-denv + timepoints: spread n_timepoints=5 per position; the source frames of each position are in the store's .provenance.json sidecar + positions: all source positions +train: + count: 0 + fovs: [] +test: + count: 12 + fovs: + - 0/0/fov0000 + - 0/0/fov0001 + - 0/0/fov0002 + - 0/0/fov0003 + - 0/0/fov0004 + - 0/0/fov0005 + - 0/0/fov0006 + - 0/0/fov0007 + - 0/0/fov0008 + - 0/0/fov0009 + - 0/0/fov0010 + - 0/0/fov0011 diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-denv/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-denv/manifest.yaml index 3cd86826b..14b2e80a6 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-denv/manifest.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-denv/manifest.yaml @@ -20,8 +20,8 @@ targets: display_name: ER (Sec61b) target_channel: Structure stores: - train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/SEC61B_DENV.ozx - test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/SEC61B_DENV.ozx - cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/SEC61B_DENV_seg_cleaned.zarr + train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all.zarr + test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/SEC61B_DENV.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/SEC61B_DENV_seg_cleaned.zarr gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache/sec61b_denv splits: splits/sec61b_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-denv/splits/sec61b_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-denv/splits/sec61b_train_test.yaml index e001c1ff6..9bfd83db6 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-denv/splits/sec61b_train_test.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-denv/splits/sec61b_train_test.yaml @@ -8,8 +8,8 @@ selection_criteria: train: count: 2 fovs: - - 0/0/fov0000 - - 0/0/fov0001 + - 0/0/fov0012 + - 0/0/fov0013 test: count: 12 fovs: diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-mock-lite/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-mock-lite/manifest.yaml new file mode 100644 index 000000000..4ca937885 --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-mock-lite/manifest.yaml @@ -0,0 +1,26 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-sec61b-mock/manifest.yaml. Do not edit; regenerate. +name: a549-mantis-sec61b-mock-lite +version: '1' +description: 'DynaCell-lite test subset of a549-mantis-sec61b-mock, built by build_temporal_subset_zarr.py and registered + by generate_lite_benchmark_configs.py. Test-only: no train store.' +cell_type: A549 +imaging_modality: mantis-lightsheet +spacing: + z: 0.174 + y: 0.1494 + x: 0.1494 +channels: + source: Phase3D + auxiliary: + - Brightfield +targets: + sec61b: + gene: SEC61B + organelle: er + display_name: ER (Sec61b) + target_channel: Structure + stores: + test: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/SEC61B_mock.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/SEC61B_mock_seg_cleaned.zarr + gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache/sec61b_mock + splits: splits/sec61b_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-mock-lite/splits/sec61b_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-mock-lite/splits/sec61b_train_test.yaml new file mode 100644 index 000000000..4dd59ea9b --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-mock-lite/splits/sec61b_train_test.yaml @@ -0,0 +1,27 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-sec61b-mock/manifest.yaml. Do not edit; regenerate. +split_version: '1' +random_seed: 0 +source_stores: +- /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/SEC61B_mock.zarr +selection_criteria: + lite_of: a549-mantis-sec61b-mock + timepoints: spread n_timepoints=5 per position; the source frames of each position are in the store's .provenance.json sidecar + positions: all source positions +train: + count: 0 + fovs: [] +test: + count: 12 + fovs: + - 0/0/fov0000 + - 0/0/fov0001 + - 0/0/fov0002 + - 0/0/fov0003 + - 0/0/fov0004 + - 0/0/fov0005 + - 0/0/fov0006 + - 0/0/fov0007 + - 0/0/fov0008 + - 0/0/fov0009 + - 0/0/fov0010 + - 0/0/fov0011 diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-mock/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-mock/manifest.yaml index 3eeb1f45c..5f0b6631e 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-mock/manifest.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-mock/manifest.yaml @@ -20,8 +20,8 @@ targets: display_name: ER (Sec61b) target_channel: Structure stores: - train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/SEC61B_mock.ozx - test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/SEC61B_mock.ozx - cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/SEC61B_mock_seg_cleaned.zarr + train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all.zarr + test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/SEC61B_mock.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/SEC61B_mock_seg_cleaned.zarr gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache/sec61b_mock splits: splits/sec61b_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-mock/splits/sec61b_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-mock/splits/sec61b_train_test.yaml index 18141424a..cee9cefb2 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-mock/splits/sec61b_train_test.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-mock/splits/sec61b_train_test.yaml @@ -8,17 +8,17 @@ selection_criteria: train: count: 11 fovs: - - 0/0/fov0000 - - 0/0/fov0001 - - 0/0/fov0002 - - 0/0/fov0003 - - 0/0/fov0004 - - 0/0/fov0005 - - 0/0/fov0006 - - 0/0/fov0007 - - 0/0/fov0008 - - 0/0/fov0009 - - 0/0/fov0010 + - 0/0/fov0014 + - 0/0/fov0015 + - 0/0/fov0016 + - 0/0/fov0017 + - 0/0/fov0018 + - 0/0/fov0019 + - 0/0/fov0020 + - 0/0/fov0021 + - 0/0/fov0022 + - 0/0/fov0023 + - 0/0/fov0024 test: count: 12 fovs: diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-zikv-lite/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-zikv-lite/manifest.yaml new file mode 100644 index 000000000..63d18d303 --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-zikv-lite/manifest.yaml @@ -0,0 +1,26 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-sec61b-zikv/manifest.yaml. Do not edit; regenerate. +name: a549-mantis-sec61b-zikv-lite +version: '1' +description: 'DynaCell-lite test subset of a549-mantis-sec61b-zikv, built by build_temporal_subset_zarr.py and registered + by generate_lite_benchmark_configs.py. Test-only: no train store.' +cell_type: A549 +imaging_modality: mantis-lightsheet +spacing: + z: 0.174 + y: 0.1494 + x: 0.1494 +channels: + source: Phase3D + auxiliary: + - Brightfield +targets: + sec61b: + gene: SEC61B + organelle: er + display_name: ER (Sec61b) + target_channel: Structure + stores: + test: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/SEC61B_ZIKV.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/SEC61B_ZIKV_seg_cleaned.zarr + gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache/sec61b_zikv + splits: splits/sec61b_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-zikv-lite/splits/sec61b_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-zikv-lite/splits/sec61b_train_test.yaml new file mode 100644 index 000000000..e01555b04 --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-zikv-lite/splits/sec61b_train_test.yaml @@ -0,0 +1,27 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-sec61b-zikv/manifest.yaml. Do not edit; regenerate. +split_version: '1' +random_seed: 0 +source_stores: +- /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/SEC61B_ZIKV.zarr +selection_criteria: + lite_of: a549-mantis-sec61b-zikv + timepoints: spread n_timepoints=5 per position; the source frames of each position are in the store's .provenance.json sidecar + positions: all source positions +train: + count: 0 + fovs: [] +test: + count: 12 + fovs: + - 0/0/fov0000 + - 0/0/fov0001 + - 0/0/fov0002 + - 0/0/fov0003 + - 0/0/fov0004 + - 0/0/fov0005 + - 0/0/fov0006 + - 0/0/fov0007 + - 0/0/fov0008 + - 0/0/fov0009 + - 0/0/fov0010 + - 0/0/fov0011 diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-zikv/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-zikv/manifest.yaml index 70affa040..4d30e937b 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-zikv/manifest.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-zikv/manifest.yaml @@ -20,8 +20,8 @@ targets: display_name: ER (Sec61b) target_channel: Structure stores: - train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/SEC61B_ZIKV.ozx - test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/SEC61B_ZIKV.ozx - cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/SEC61B_ZIKV_seg_cleaned.zarr + train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/SEC61B_all.zarr + test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/SEC61B_ZIKV.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/SEC61B_ZIKV_seg_cleaned.zarr gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache/sec61b_zikv splits: splits/sec61b_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-zikv/splits/sec61b_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-zikv/splits/sec61b_train_test.yaml index fb2693ada..a7275e2bf 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-zikv/splits/sec61b_train_test.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-sec61b-zikv/splits/sec61b_train_test.yaml @@ -20,9 +20,9 @@ train: - 0/0/fov0009 - 0/0/fov0010 - 0/0/fov0011 - - 0/0/fov0012 - - 0/0/fov0013 - - 0/0/fov0014 + - 0/0/fov0025 + - 0/0/fov0026 + - 0/0/fov0027 test: count: 12 fovs: diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-denv-lite/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-denv-lite/manifest.yaml new file mode 100644 index 000000000..7650fe223 --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-denv-lite/manifest.yaml @@ -0,0 +1,26 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-tomm20-denv/manifest.yaml. Do not edit; regenerate. +name: a549-mantis-tomm20-denv-lite +version: '1' +description: 'DynaCell-lite test subset of a549-mantis-tomm20-denv, built by build_temporal_subset_zarr.py and registered + by generate_lite_benchmark_configs.py. Test-only: no train store.' +cell_type: A549 +imaging_modality: mantis-lightsheet +spacing: + z: 0.174 + y: 0.1494 + x: 0.1494 +channels: + source: Phase3D + auxiliary: + - Brightfield +targets: + tomm20: + gene: TOMM20 + organelle: mitochondria + display_name: Mitochondria (TOMM20) + target_channel: Structure + stores: + test: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/TOMM20_DENV.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/TOMM20_DENV_seg_cleaned.zarr + gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache/tomm20_denv + splits: splits/tomm20_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-denv-lite/splits/tomm20_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-denv-lite/splits/tomm20_train_test.yaml new file mode 100644 index 000000000..692902e7b --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-denv-lite/splits/tomm20_train_test.yaml @@ -0,0 +1,27 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-tomm20-denv/manifest.yaml. Do not edit; regenerate. +split_version: '1' +random_seed: 0 +source_stores: +- /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/TOMM20_DENV.zarr +selection_criteria: + lite_of: a549-mantis-tomm20-denv + timepoints: spread n_timepoints=5 per position; the source frames of each position are in the store's .provenance.json sidecar + positions: all source positions +train: + count: 0 + fovs: [] +test: + count: 12 + fovs: + - 0/0/fov0000 + - 0/0/fov0001 + - 0/0/fov0002 + - 0/0/fov0003 + - 0/0/fov0004 + - 0/0/fov0005 + - 0/0/fov0006 + - 0/0/fov0007 + - 0/0/fov0008 + - 0/0/fov0009 + - 0/0/fov0010 + - 0/0/fov0011 diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-denv/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-denv/manifest.yaml index c25922437..f8ae1761f 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-denv/manifest.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-denv/manifest.yaml @@ -20,8 +20,8 @@ targets: display_name: Mitochondria (TOMM20) target_channel: Structure stores: - train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/TOMM20_DENV.ozx - test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/TOMM20_DENV.ozx - cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/TOMM20_DENV_seg_cleaned.zarr + train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all.zarr + test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/TOMM20_DENV.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/TOMM20_DENV_seg_cleaned.zarr gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache/tomm20_denv splits: splits/tomm20_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-denv/splits/tomm20_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-denv/splits/tomm20_train_test.yaml index 76678fa21..b87eb5bf0 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-denv/splits/tomm20_train_test.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-denv/splits/tomm20_train_test.yaml @@ -8,11 +8,11 @@ selection_criteria: train: count: 5 fovs: - - 0/0/fov0000 - - 0/0/fov0001 - - 0/0/fov0002 - - 0/0/fov0003 - - 0/0/fov0004 + - 0/0/fov0010 + - 0/0/fov0011 + - 0/0/fov0012 + - 0/0/fov0013 + - 0/0/fov0014 test: count: 12 fovs: diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-mock-lite/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-mock-lite/manifest.yaml new file mode 100644 index 000000000..0828b3792 --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-mock-lite/manifest.yaml @@ -0,0 +1,26 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-tomm20-mock/manifest.yaml. Do not edit; regenerate. +name: a549-mantis-tomm20-mock-lite +version: '1' +description: 'DynaCell-lite test subset of a549-mantis-tomm20-mock, built by build_temporal_subset_zarr.py and registered + by generate_lite_benchmark_configs.py. Test-only: no train store.' +cell_type: A549 +imaging_modality: mantis-lightsheet +spacing: + z: 0.174 + y: 0.1494 + x: 0.1494 +channels: + source: Phase3D + auxiliary: + - Brightfield +targets: + tomm20: + gene: TOMM20 + organelle: mitochondria + display_name: Mitochondria (TOMM20) + target_channel: Structure + stores: + test: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/TOMM20_mock.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/TOMM20_mock_seg_cleaned.zarr + gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache/tomm20_mock + splits: splits/tomm20_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-mock-lite/splits/tomm20_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-mock-lite/splits/tomm20_train_test.yaml new file mode 100644 index 000000000..b6193f9eb --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-mock-lite/splits/tomm20_train_test.yaml @@ -0,0 +1,27 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-tomm20-mock/manifest.yaml. Do not edit; regenerate. +split_version: '1' +random_seed: 0 +source_stores: +- /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/TOMM20_mock.zarr +selection_criteria: + lite_of: a549-mantis-tomm20-mock + timepoints: spread n_timepoints=5 per position; the source frames of each position are in the store's .provenance.json sidecar + positions: all source positions +train: + count: 0 + fovs: [] +test: + count: 12 + fovs: + - 0/0/fov0000 + - 0/0/fov0001 + - 0/0/fov0002 + - 0/0/fov0003 + - 0/0/fov0004 + - 0/0/fov0005 + - 0/0/fov0006 + - 0/0/fov0007 + - 0/0/fov0008 + - 0/0/fov0009 + - 0/0/fov0010 + - 0/0/fov0011 diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-mock/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-mock/manifest.yaml index e9940a947..74cc8c673 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-mock/manifest.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-mock/manifest.yaml @@ -20,8 +20,8 @@ targets: display_name: Mitochondria (TOMM20) target_channel: Structure stores: - train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/TOMM20_mock.ozx - test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/TOMM20_mock.ozx - cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/TOMM20_mock_seg_cleaned.zarr + train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all.zarr + test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/TOMM20_mock.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/TOMM20_mock_seg_cleaned.zarr gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache/tomm20_mock splits: splits/tomm20_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-mock/splits/tomm20_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-mock/splits/tomm20_train_test.yaml index 9009cf38c..56a7d745e 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-mock/splits/tomm20_train_test.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-mock/splits/tomm20_train_test.yaml @@ -14,13 +14,13 @@ train: - 0/0/fov0003 - 0/0/fov0004 - 0/0/fov0005 - - 0/0/fov0006 - - 0/0/fov0007 - - 0/0/fov0008 - - 0/0/fov0009 - - 0/0/fov0010 - - 0/0/fov0011 - - 0/0/fov0012 + - 0/0/fov0015 + - 0/0/fov0016 + - 0/0/fov0017 + - 0/0/fov0018 + - 0/0/fov0024 + - 0/0/fov0025 + - 0/0/fov0026 test: count: 12 fovs: diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-zikv-lite/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-zikv-lite/manifest.yaml new file mode 100644 index 000000000..2290ef803 --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-zikv-lite/manifest.yaml @@ -0,0 +1,26 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-tomm20-zikv/manifest.yaml. Do not edit; regenerate. +name: a549-mantis-tomm20-zikv-lite +version: '1' +description: 'DynaCell-lite test subset of a549-mantis-tomm20-zikv, built by build_temporal_subset_zarr.py and registered + by generate_lite_benchmark_configs.py. Test-only: no train store.' +cell_type: A549 +imaging_modality: mantis-lightsheet +spacing: + z: 0.174 + y: 0.1494 + x: 0.1494 +channels: + source: Phase3D + auxiliary: + - Brightfield +targets: + tomm20: + gene: TOMM20 + organelle: mitochondria + display_name: Mitochondria (TOMM20) + target_channel: Structure + stores: + test: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/TOMM20_ZIKV.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell_lite/a549/mantis/test/TOMM20_ZIKV_seg_cleaned.zarr + gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/a549/eval_cache/tomm20_zikv + splits: splits/tomm20_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-zikv-lite/splits/tomm20_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-zikv-lite/splits/tomm20_train_test.yaml new file mode 100644 index 000000000..f1ade074b --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-zikv-lite/splits/tomm20_train_test.yaml @@ -0,0 +1,27 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/a549-mantis-tomm20-zikv/manifest.yaml. Do not edit; regenerate. +split_version: '1' +random_seed: 0 +source_stores: +- /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/TOMM20_ZIKV.zarr +selection_criteria: + lite_of: a549-mantis-tomm20-zikv + timepoints: spread n_timepoints=5 per position; the source frames of each position are in the store's .provenance.json sidecar + positions: all source positions +train: + count: 0 + fovs: [] +test: + count: 12 + fovs: + - 0/0/fov0000 + - 0/0/fov0001 + - 0/0/fov0002 + - 0/0/fov0003 + - 0/0/fov0004 + - 0/0/fov0005 + - 0/0/fov0006 + - 0/0/fov0007 + - 0/0/fov0008 + - 0/0/fov0009 + - 0/0/fov0010 + - 0/0/fov0011 diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-zikv/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-zikv/manifest.yaml index df63e66d0..6bc071a2d 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-zikv/manifest.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-zikv/manifest.yaml @@ -20,8 +20,8 @@ targets: display_name: Mitochondria (TOMM20) target_channel: Structure stores: - train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/train/TOMM20_ZIKV.ozx - test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/TOMM20_ZIKV.ozx - cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis_v1/test/TOMM20_ZIKV_seg_cleaned.zarr + train: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/train/TOMM20_all.zarr + test: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/TOMM20_ZIKV.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/a549/mantis/test/TOMM20_ZIKV_seg_cleaned.zarr gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell/a549/eval_cache/tomm20_zikv splits: splits/tomm20_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-zikv/splits/tomm20_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-zikv/splits/tomm20_train_test.yaml index 909097382..7a0edd442 100644 --- a/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-zikv/splits/tomm20_train_test.yaml +++ b/applications/dynacell/src/dynacell/_manifests/a549-mantis-tomm20-zikv/splits/tomm20_train_test.yaml @@ -8,18 +8,18 @@ selection_criteria: train: count: 12 fovs: - - 0/0/fov0000 - - 0/0/fov0001 - - 0/0/fov0002 - - 0/0/fov0003 - - 0/0/fov0004 - - 0/0/fov0005 - 0/0/fov0006 - 0/0/fov0007 - 0/0/fov0008 - 0/0/fov0009 - - 0/0/fov0010 - - 0/0/fov0011 + - 0/0/fov0019 + - 0/0/fov0020 + - 0/0/fov0021 + - 0/0/fov0022 + - 0/0/fov0023 + - 0/0/fov0027 + - 0/0/fov0028 + - 0/0/fov0029 test: count: 12 fovs: diff --git a/applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/manifest.yaml new file mode 100644 index 000000000..5d313bb03 --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/manifest.yaml @@ -0,0 +1,58 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/aics-hipsc/manifest.yaml. Do not edit; regenerate. +name: aics-hipsc-lite +version: '4' +description: 'DynaCell-lite test subset of aics-hipsc, built by build_temporal_subset_zarr.py and registered by generate_lite_benchmark_configs.py. + Test-only: no train store.' +cell_type: WTC-11 hiPSC +imaging_modality: confocal +spacing: + z: 0.29 + y: 0.108 + x: 0.108 +channels: + source: Phase3D + auxiliary: + - Brightfield + - Nuclei + - Membrane +targets: + sec61b: + gene: SEC61B + organelle: er + display_name: ER (Sec61b) + target_channel: Structure + stores: + test: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/dataset_v4/test_cropped/SEC61B.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/dataset_v4/test_cropped/SEC61B_segmented_cleaned.zarr + gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache/SEC61B + splits: splits/sec61b_train_val_test.yaml + tomm20: + gene: TOMM20 + organelle: mitochondria + display_name: Mitochondria (TOMM20) + target_channel: Structure + stores: + test: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/dataset_v4/test_cropped/TOMM20.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/dataset_v4/test_cropped/TOMM20_segmented_cleaned.zarr + gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache/TOMM20 + splits: splits/tomm20_train_val_test.yaml + nucleus: + gene: Nuclei + organelle: nucleus + display_name: Nucleus + target_channel: Nuclei + stores: + test: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/dataset_v4/test_cropped/cell.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/dataset_v4/test_cropped/cell_segmented_cleaned.zarr + gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache/nucleus + splits: splits/nucleus_train_val_test.yaml + membrane: + gene: Membrane + organelle: membrane + display_name: Membrane + target_channel: Membrane + stores: + test: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/dataset_v4/test_cropped/cell.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/dataset_v4/test_cropped/cell_segmented_cleaned.zarr + gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell_lite/ipsc/eval_cache/membrane + splits: splits/membrane_train_val_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/splits/membrane_train_val_test.yaml b/applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/splits/membrane_train_val_test.yaml new file mode 100644 index 000000000..400730a0b --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/splits/membrane_train_val_test.yaml @@ -0,0 +1,65 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/aics-hipsc/manifest.yaml. Do not edit; regenerate. +split_version: '1' +random_seed: 0 +source_stores: +- /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/cell.zarr +selection_criteria: + lite_of: aics-hipsc + timepoints: early n_timepoints=1 per position; the source frames of each position are in the store's .provenance.json sidecar + positions: numpy default_rng(0).choice(sorted source names, 50, replace=False), sorted +train: + count: 0 + fovs: [] +test: + count: 50 + fovs: + - 4/11393/1428 + - 4/11479/1481 + - 4/18007/1641 + - 4/18485/1842 + - 4/27797/2857 + - 4/28759/3400 + - 4/29334/3890 + - 4/30293/3915 + - 4/34998/4271 + - 4/36643/4930 + - 4/4556/15828 + - 4/94507/699 + - 41/44212/5751 + - 41/48436/5515 + - 41/49121/5716 + - 41/49204/5680 + - 41/49975/5926 + - 41/53048/15203 + - 41/55348/6437 + - 41/55350/6427 + - 41/60728/7413 + - 41/62754/7076 + - 41/63713/7287 + - 41/67168/7688 + - 41/68598/9132 + - 41/72629/8071 + - 41/72727/8125 + - 41/73304/8259 + - 41/73686/8660 + - 41/73783/8567 + - 41/74264/8751 + - 41/74272/8740 + - 41/75808/7975 + - 42/107478/10817 + - 42/116598/10604 + - 42/117557/11343 + - 42/118912/11694 + - 42/123916/16655 + - 42/124001/16229 + - 42/127276/23725 + - 42/127939/12482 + - 42/128428/12536 + - 42/129665/12780 + - 42/135439/14132 + - 42/137449/14744 + - 42/137455/14731 + - 42/137460/14685 + - 42/137582/14642 + - 42/137820/14488 + - 42/80023/9994 diff --git a/applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/splits/nucleus_train_val_test.yaml b/applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/splits/nucleus_train_val_test.yaml new file mode 100644 index 000000000..400730a0b --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/splits/nucleus_train_val_test.yaml @@ -0,0 +1,65 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/aics-hipsc/manifest.yaml. Do not edit; regenerate. +split_version: '1' +random_seed: 0 +source_stores: +- /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/cell.zarr +selection_criteria: + lite_of: aics-hipsc + timepoints: early n_timepoints=1 per position; the source frames of each position are in the store's .provenance.json sidecar + positions: numpy default_rng(0).choice(sorted source names, 50, replace=False), sorted +train: + count: 0 + fovs: [] +test: + count: 50 + fovs: + - 4/11393/1428 + - 4/11479/1481 + - 4/18007/1641 + - 4/18485/1842 + - 4/27797/2857 + - 4/28759/3400 + - 4/29334/3890 + - 4/30293/3915 + - 4/34998/4271 + - 4/36643/4930 + - 4/4556/15828 + - 4/94507/699 + - 41/44212/5751 + - 41/48436/5515 + - 41/49121/5716 + - 41/49204/5680 + - 41/49975/5926 + - 41/53048/15203 + - 41/55348/6437 + - 41/55350/6427 + - 41/60728/7413 + - 41/62754/7076 + - 41/63713/7287 + - 41/67168/7688 + - 41/68598/9132 + - 41/72629/8071 + - 41/72727/8125 + - 41/73304/8259 + - 41/73686/8660 + - 41/73783/8567 + - 41/74264/8751 + - 41/74272/8740 + - 41/75808/7975 + - 42/107478/10817 + - 42/116598/10604 + - 42/117557/11343 + - 42/118912/11694 + - 42/123916/16655 + - 42/124001/16229 + - 42/127276/23725 + - 42/127939/12482 + - 42/128428/12536 + - 42/129665/12780 + - 42/135439/14132 + - 42/137449/14744 + - 42/137455/14731 + - 42/137460/14685 + - 42/137582/14642 + - 42/137820/14488 + - 42/80023/9994 diff --git a/applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/splits/sec61b_train_val_test.yaml b/applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/splits/sec61b_train_val_test.yaml new file mode 100644 index 000000000..5335c4c0d --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/splits/sec61b_train_val_test.yaml @@ -0,0 +1,65 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/aics-hipsc/manifest.yaml. Do not edit; regenerate. +split_version: '1' +random_seed: 0 +source_stores: +- /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/SEC61B.zarr +selection_criteria: + lite_of: aics-hipsc + timepoints: early n_timepoints=1 per position; the source frames of each position are in the store's .provenance.json sidecar + positions: numpy default_rng(0).choice(sorted source names, 50, replace=False), sorted +train: + count: 0 + fovs: [] +test: + count: 50 + fovs: + - 4/38452/5187 + - 4/38452/5201 + - 4/38452/5203 + - 4/38465/5189 + - 4/39124/5286 + - 4/39125/5224 + - 4/39128/5254 + - 4/39137/5252 + - 4/39222/5281 + - 4/39232/5329 + - 4/39233/5327 + - 4/40181/5434 + - 4/40181/5451 + - 4/40181/5453 + - 4/40196/5471 + - 4/40376/4568 + - 4/40376/4604 + - 4/40385/4576 + - 4/40386/4603 + - 4/40386/4606 + - 4/40468/4624 + - 4/40471/4659 + - 4/40481/4627 + - 4/40483/4637 + - 4/40960/4630 + - 4/41047/4885 + - 4/41059/4886 + - 4/41238/4828 + - 4/41239/4823 + - 4/41240/4818 + - 4/41240/4834 + - 4/41335/4803 + - 4/41428/4718 + - 4/41428/4743 + - 4/41441/4725 + - 4/41908/5037 + - 4/41909/5071 + - 4/41910/5031 + - 4/41910/5058 + - 4/41911/5027 + - 4/42199/5048 + - 4/42211/5034 + - 42/136118/14225 + - 42/136120/14228 + - 42/136120/15747 + - 42/136124/16127 + - 42/138024/17222 + - 42/138026/17232 + - 42/138028/17202 + - 42/138045/16692 diff --git a/applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/splits/tomm20_train_val_test.yaml b/applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/splits/tomm20_train_val_test.yaml new file mode 100644 index 000000000..7180aa639 --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/aics-hipsc-lite/splits/tomm20_train_val_test.yaml @@ -0,0 +1,65 @@ +# Auto-generated by tools/generate_lite_benchmark_configs.py from src/dynacell/_manifests/aics-hipsc/manifest.yaml. Do not edit; regenerate. +split_version: '1' +random_seed: 0 +source_stores: +- /hpc/projects/virtual_staining/training/dynacell/ipsc/dataset_v4/test_cropped/TOMM20.zarr +selection_criteria: + lite_of: aics-hipsc + timepoints: early n_timepoints=1 per position; the source frames of each position are in the store's .provenance.json sidecar + positions: numpy default_rng(0).choice(sorted source names, 50, replace=False), sorted +train: + count: 0 + fovs: [] +test: + count: 50 + fovs: + - 4/10612/1362 + - 4/10624/1349 + - 4/11380/1459 + - 4/11384/1404 + - 4/11477/1493 + - 4/11492/1472 + - 4/11680/1686 + - 4/11682/1660 + - 4/22133/2798 + - 4/22135/2822 + - 4/22327/3137 + - 4/23381/3195 + - 4/23382/3245 + - 4/23384/3170 + - 4/23394/3196 + - 4/23768/3424 + - 4/24149/3481 + - 4/24724/3649 + - 4/24930/3599 + - 4/24931/3592 + - 4/25207/3824 + - 4/27798/2891 + - 4/27990/3012 + - 4/27991/3028 + - 4/28084/3200 + - 4/29142/3718 + - 4/29143/3679 + - 4/29332/3860 + - 4/29336/3885 + - 4/30292/3909 + - 4/30294/3901 + - 4/30391/15032 + - 4/5143/953 + - 4/5240/1073 + - 4/6486/989 + - 4/6486/991 + - 4/6776/1122 + - 4/7349/1359 + - 4/7638/1280 + - 4/7650/1285 + - 4/8228/886 + - 4/8228/893 + - 4/8692/1235 + - 4/9748/16574 + - 4/9748/16977 + - 4/9749/16734 + - 42/135525/16168 + - 42/135615/14189 + - 42/136130/14325 + - 42/136136/14317 diff --git a/applications/dynacell/src/dynacell/_manifests/hek-mantis-kras-a549xy/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/hek-mantis-kras-a549xy/manifest.yaml new file mode 100644 index 000000000..8eedd13d2 --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/hek-mantis-kras-a549xy/manifest.yaml @@ -0,0 +1,34 @@ +name: hek-mantis-kras-a549xy +version: '1' +description: >- + HEK293T OpenCell KRAS-mNeonGreen (plasma membrane) imaged on mantis; the 4 + QC-passing figure_3 FOVs. Third-cell-type probe for the NeurIPS response + (item O): the same instrument as the A549 dataset, so it supplies a cell-type + axis at fixed instrument. XY is resampled 0.116 -> 0.1494 um to the A549 + assembly pitch (the same downsample the A549 pools took at assembly time); + Z is left at the native mantis 0.205 um, so lateral sampling matches A549 but + axial sampling does not. Evaluation-only: no HEK training, hence no train + store. Source: + /hpc/projects/comp.micro/mantis/mantis_paper_data_release/dynacell/HEK/figure_3_flipped_crop32_z64.zarr +cell_type: HEK293T +imaging_modality: mantis-lightsheet +spacing: + z: 0.205 + y: 0.1494 + x: 0.1494 +channels: + source: Phase3D + auxiliary: + - Brightfield + - Membrane_label +targets: + kras: + gene: KRAS + organelle: membrane + display_name: Membrane (KRAS) + target_channel: Membrane + stores: + test: /hpc/projects/virtual_staining/training/dynacell/hek/mantis/test/KRAS_a549xy.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/hek/mantis/test/KRAS_a549xy_seg_cleaned.zarr + gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache/kras_a549xy + splits: splits/kras_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/hek-mantis-kras-a549xy/splits/kras_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/hek-mantis-kras-a549xy/splits/kras_train_test.yaml new file mode 100644 index 000000000..9f0eb368c --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/hek-mantis-kras-a549xy/splits/kras_train_test.yaml @@ -0,0 +1,24 @@ +split_version: '1' +random_seed: 0 +source_stores: +- /hpc/projects/comp.micro/mantis/mantis_paper_data_release/dynacell/HEK/figure_3_flipped_crop32_z64.zarr +selection_criteria: + source: mantis paper release figure_3 (OpenCell targets), well KRAS + qc: >- + All 4 figure_3 FOVs pass QC (good signal, good registration) per Confluence + MUG/5539627037. The figure_3 nucleus (HIST2H2BE) and ER (SEC61B) wells fail + QC (misregistration, lower half out of focus) and are not part of this + registry. + role: >- + Evaluation-only third-cell-type probe. No HEK training was performed, so + there is no train split and the manifest defines no train store. +train: + count: 0 + fovs: [] +test: + count: 4 + fovs: + - 0/KRAS/000000 + - 0/KRAS/000001 + - 0/KRAS/001000 + - 0/KRAS/001001 diff --git a/applications/dynacell/src/dynacell/_manifests/hek-mantis-tomm70a-a549xy/manifest.yaml b/applications/dynacell/src/dynacell/_manifests/hek-mantis-tomm70a-a549xy/manifest.yaml new file mode 100644 index 000000000..187b3423a --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/hek-mantis-tomm70a-a549xy/manifest.yaml @@ -0,0 +1,34 @@ +name: hek-mantis-tomm70a-a549xy +version: '1' +description: >- + HEK293T OpenCell TOMM70A-mNeonGreen (mitochondrial outer membrane) imaged on + mantis; the 4 QC-passing figure_3 FOVs. Third-cell-type probe for the NeurIPS + response (item O): the same instrument as the A549 dataset, so it supplies a + cell-type axis at fixed instrument. XY is resampled 0.116 -> 0.1494 um to the + A549 assembly pitch (the same downsample the A549 pools took at assembly + time); Z is left at the native mantis 0.205 um, so lateral sampling matches + A549 but axial sampling does not. Evaluation-only: no HEK training, hence no + train store. Source: + /hpc/projects/comp.micro/mantis/mantis_paper_data_release/dynacell/HEK/figure_3_flipped_crop32_z64.zarr +cell_type: HEK293T +imaging_modality: mantis-lightsheet +spacing: + z: 0.205 + y: 0.1494 + x: 0.1494 +channels: + source: Phase3D + auxiliary: + - Brightfield + - Membrane_label +targets: + tomm70a: + gene: TOMM70A + organelle: mitochondria + display_name: Mitochondria (TOMM70) + target_channel: Structure + stores: + test: /hpc/projects/virtual_staining/training/dynacell/hek/mantis/test/TOMM70A_a549xy.zarr + cell_segmentation: /hpc/projects/virtual_staining/training/dynacell/hek/mantis/test/TOMM70A_a549xy_seg_cleaned.zarr + gt_cache_dir: /hpc/projects/virtual_staining/training/dynacell/hek/eval_cache/tomm70a_a549xy + splits: splits/tomm70a_train_test.yaml diff --git a/applications/dynacell/src/dynacell/_manifests/hek-mantis-tomm70a-a549xy/splits/tomm70a_train_test.yaml b/applications/dynacell/src/dynacell/_manifests/hek-mantis-tomm70a-a549xy/splits/tomm70a_train_test.yaml new file mode 100644 index 000000000..75d2adb0f --- /dev/null +++ b/applications/dynacell/src/dynacell/_manifests/hek-mantis-tomm70a-a549xy/splits/tomm70a_train_test.yaml @@ -0,0 +1,24 @@ +split_version: '1' +random_seed: 0 +source_stores: +- /hpc/projects/comp.micro/mantis/mantis_paper_data_release/dynacell/HEK/figure_3_flipped_crop32_z64.zarr +selection_criteria: + source: mantis paper release figure_3 (OpenCell targets), well TOMM70A + qc: >- + All 4 figure_3 FOVs pass QC (good signal, good registration) per Confluence + MUG/5539627037. The figure_3 nucleus (HIST2H2BE) and ER (SEC61B) wells fail + QC (misregistration, lower half out of focus) and are not part of this + registry. + role: >- + Evaluation-only third-cell-type probe. No HEK training was performed, so + there is no train split and the manifest defines no train store. +train: + count: 0 + fovs: [] +test: + count: 4 + fovs: + - 0/TOMM70A/000000 + - 0/TOMM70A/000001 + - 0/TOMM70A/001000 + - 0/TOMM70A/001001 diff --git a/applications/dynacell/src/dynacell/celldiff_wrapper.py b/applications/dynacell/src/dynacell/celldiff_wrapper.py index c80c2ab0c..eb03d43b0 100644 --- a/applications/dynacell/src/dynacell/celldiff_wrapper.py +++ b/applications/dynacell/src/dynacell/celldiff_wrapper.py @@ -9,13 +9,74 @@ The reusable backbone and transport numerics live in ``viscy-models``. """ +import copy import itertools +from collections.abc import Callable import torch from torch import Tensor, nn +from dynacell.mask_conditioning import binarize_mask, encode_mask +from dynacell.tiling import window_starts from viscy_models.celldiff import CELLDiffNet from viscy_models.celldiff.modules.transport import Sampler, create_transport +from viscy_models.celldiff.modules.transport.utils import expand_t_like_x +from viscy_utils.losses import SegAuxDice + + +class _ChannelsLastGroupNorm(nn.GroupNorm): + """GroupNorm computed over the NDHWC view of a ``channels_last_3d`` input. + + Same parameters and result as :class:`torch.nn.GroupNorm`, statistics in + float32, but reduced along the contiguous channel axis: compiled, this is + a coalesced reduction, where ``nn.GroupNorm`` on a channels-last input + compiles to strided ones (measured ~8x slower). The output keeps the + input dtype under autocast, which would otherwise run GroupNorm and the + activation chain after it in float32. + """ + + def forward(self, x: Tensor) -> Tensor: + """Normalize ``x`` of shape ``(B, C, D, H, W)``; returns ``x.dtype`` in ``x``'s memory format.""" + with torch.autocast(x.device.type, enabled=False): + n, c = x.shape[:2] + xl = x.permute(0, 2, 3, 4, 1) + xs = xl.reshape(n, -1, self.num_groups, c // self.num_groups).float() + var, mean = torch.var_mean(xs, dim=(1, 3), keepdim=True, correction=0) + y = ((xs - mean) * torch.rsqrt(var + self.eps)).reshape(xl.shape) + y = y * self.weight.float() + self.bias.float() + return y.to(x.dtype).permute(0, 4, 1, 2, 3) + + +def _channels_last_copy(net: CELLDiffNet) -> CELLDiffNet: + """Copy of ``net`` laid out for compiled inference, with the weights it has now. + + Conv weights become ``channels_last_3d`` (cuDNN's native layout; on + contiguous tensors it transposes around every conv), in the active + autocast dtype: an autocast cast inside the compiled graph would lay the + weight out contiguous again. GroupNorm becomes + :class:`_ChannelsLastGroupNorm`. Measured on an A100, 8x512x512 at batch + 4 in bf16: 385 -> 309 ms per forward, the same 0.0033 relative L2 to the + float32 net. + + Parameters + ---------- + net : CELLDiffNet + Velocity network; not modified. + + Returns + ------- + CELLDiffNet + The converted copy. + """ + device = next(net.parameters()).device.type + dtype = torch.get_autocast_dtype(device) if torch.is_autocast_enabled(device) else None + net = copy.deepcopy(net) + for module in net.modules(): + if isinstance(module, (nn.Conv3d, nn.ConvTranspose3d)): + module.to(dtype=dtype, memory_format=torch.channels_last_3d) + elif type(module) is nn.GroupNorm: + module.__class__ = _ChannelsLastGroupNorm + return net class CELLDiff3DVS(nn.Module): @@ -38,6 +99,24 @@ class CELLDiff3DVS(nn.Module): Training epsilon for transport stability. sample_eps : float or None Sampling epsilon for transport stability. + seg_aux : SegAuxDice or None + Auxiliary segmentation loss on the one-step data estimate + ``x1_hat = x_t + (1 - t) * v_hat`` (linear path, t=1 is data). Only + consulted when ``forward`` receives ``fg_mask``; requires + ``path_type="Linear"`` and ``prediction="velocity"``, the only case in + which that estimate is exact. + seg_aux_t0 : float + Gate for ``seg_aux``: a sample contributes only when + ``t >= 1 - seg_aux_t0``, i.e. the least-noisy ``seg_aux_t0`` fraction + of the time range. ``1.0`` is ungated. Also gates the mask Dice of + :meth:`joint_mask_losses`. + joint_mask : bool + C-joint: the flow generates ``[image, mask]``, the mask channels + being ``fg_mask`` encoded to ``{-1, 1}``; train with + :meth:`joint_mask_losses`. ``net.in_channels`` must then be twice the + target channel count, and every ``generate*`` method returns both + halves. Requires ``path_type="Linear"`` and ``prediction="velocity"`` + (the mask Dice scores ``x1_hat``). """ def __init__( @@ -48,15 +127,36 @@ def __init__( loss_weight: str | None = None, train_eps: float | None = None, sample_eps: float | None = None, + seg_aux: SegAuxDice | None = None, + seg_aux_t0: float = 0.7, + joint_mask: bool = False, ) -> None: super().__init__() + if (seg_aux is not None or joint_mask) and (path_type != "Linear" or prediction != "velocity"): + raise ValueError( + "seg_aux and joint_mask use x1_hat = x_t + (1 - t) * v_hat, which holds only for " + f"path_type='Linear' and prediction='velocity'; got {path_type!r}, {prediction!r}." + ) + if not 0.0 < seg_aux_t0 <= 1.0: + raise ValueError(f"seg_aux_t0 must be in (0, 1], got {seg_aux_t0}") self.net = net self.path_type = path_type self.prediction = prediction self.transport = create_transport(path_type, prediction, loss_weight, train_eps, sample_eps) self.transport_sampler = Sampler(self.transport) - - def forward(self, phase: Tensor, target: Tensor) -> Tensor: + self.seg_aux = seg_aux + self.seg_aux_t0 = seg_aux_t0 + self.joint_mask = joint_mask + # The compiled velocity net, built on first use from a converted copy of the weights (see + # inference_net). Kept in a dict: assigning a Module attribute would register it as a + # submodule and duplicate the weights in the state dict. + self._compiled: dict[str, Callable[[Tensor, Tensor, Tensor], Tensor]] = {} + if joint_mask and net.inconv.in_channels % 2: + raise ValueError(f"joint_mask needs net in_channels = 2 x target channels, got {net.inconv.in_channels}") + + def forward( + self, phase: Tensor, target: Tensor, fg_mask: Tensor | None = None + ) -> Tensor | tuple[Tensor, dict[str, Tensor]]: """Compute flow-matching training loss. Parameters @@ -65,21 +165,131 @@ def forward(self, phase: Tensor, target: Tensor) -> Tensor: Phase contrast input of shape ``(B, 1, D, H, W)``. target : Tensor Fluorescence target of shape ``(B, C, D, H, W)``. + fg_mask : Tensor or None + Foreground mask shaped like ``target``. When given, ``seg_aux`` + must be set and its gated Dice is returned alongside the loss. Returns ------- - Tensor - Scalar training loss. + Tensor or tuple of (Tensor, dict of str to Tensor) + Scalar velocity loss; with ``fg_mask``, also + ``{"dice", "n_valid", "n_gated"}``. ``dice`` is the batch mean of + ``1[t >= 1 - t0] * Dice(x1_hat)`` over patches with a usable mask + (unweighted; the caller applies its weight), ``n_valid`` the + patches that contributed, ``n_gated`` the samples inside the gate. + The velocity loss is the same quantity as without ``fg_mask``. """ t, x0, x1 = self.transport.sample(target) t, xt, ut = self.transport.path_sampler.plan(t, x0, x1) pred = self.net(xt, phase, t) loss_dict = self.transport.training_losses(pred, x0, x1, xt, ut, t) - return loss_dict["loss"].mean() + loss = loss_dict["loss"].mean() + if fg_mask is None: + return loss + if self.seg_aux is None: + raise ValueError("fg_mask was passed but seg_aux is not configured.") + x1_hat = xt + expand_t_like_x(1 - t, xt) * pred + dice, valid = self.seg_aux.per_channel(x1_hat, target, fg_mask) + gate = t >= 1 - self.seg_aux_t0 + contrib = valid & gate.unsqueeze(1) + # Mean over valid patches of g(t) * Dice: gated-out samples add 0 but + # still count, so the term is an unbiased estimate of E[g(t) * Dice]. + gated_dice = (dice * contrib).sum() / valid.sum().clamp(min=1) + return loss, {"dice": gated_dice, "n_valid": contrib.sum().float(), "n_gated": gate.sum().float()} + + def joint_mask_losses(self, phase: Tensor, target: Tensor, fg_mask: Tensor) -> dict[str, Tensor]: + """Compute the C-joint losses on the flow over ``[target, encoded fg_mask]``. + + One noise draw and one ``t`` per sample cover both halves. The mask + Dice is a squared-denominator soft Dice of + ``p = clamp((x1_hat_mask + 1) / 2, 0, 1)`` against the binary mask, + gated to ``t >= 1 - seg_aux_t0``; patches with an empty mask are + excluded from the mean (gated-out samples count as 0). + + Parameters + ---------- + phase : Tensor + Conditioning of shape ``(B, cond_channels, D, H, W)``. + target : Tensor + Fluorescence target of shape ``(B, C, D, H, W)``. + fg_mask : Tensor + Foreground mask shaped like ``target``; binarized at 0.5. + + Returns + ------- + dict of str to Tensor + ``velocity_image`` (the baseline's velocity loss, on the image + half), ``velocity_mask``, ``dice`` (unweighted), ``n_valid`` and + ``n_gated``. + """ + if not self.joint_mask: + raise ValueError("joint_mask_losses needs joint_mask=True.") + if fg_mask.shape != target.shape: + raise ValueError(f"fg_mask {tuple(fg_mask.shape)} must match target {tuple(target.shape)}") + n = target.shape[1] + if 2 * n != self.net.inconv.in_channels: + raise ValueError(f"target has {n} channel(s) but the net generates {self.net.inconv.in_channels}") + mask = binarize_mask(fg_mask).to(target.dtype) + t, x0, x1 = self.transport.sample(torch.cat([target, encode_mask(mask)], dim=1)) + t, xt, ut = self.transport.path_sampler.plan(t, x0, x1) + pred = self.net(xt, phase, t) + image, masked = slice(None, n), slice(n, None) + velocity = { + name: self.transport.training_losses(pred[:, sl], x0[:, sl], x1[:, sl], xt[:, sl], ut[:, sl], t)[ + "loss" + ].mean() + for name, sl in (("velocity_image", image), ("velocity_mask", masked)) + } + x1_hat = xt[:, masked] + expand_t_like_x(1 - t, xt) * pred[:, masked] + with torch.autocast(device_type=x1_hat.device.type, enabled=False): + p = ((x1_hat.float() + 1.0) / 2.0).clamp(0.0, 1.0).flatten(2) + m = mask.float().flatten(2) + dice = 1.0 - 2.0 * (p * m).sum(-1) / ((p * p).sum(-1) + m.sum(-1) + 1e-6) + valid = m.sum(-1) > 0 + gate = t >= 1 - self.seg_aux_t0 + contrib = valid & gate.unsqueeze(1) + gated_dice = (dice * contrib).sum() / valid.sum().clamp(min=1) + return { + **velocity, + "dice": gated_dice, + "n_valid": contrib.sum().float(), + "n_gated": gate.sum().float(), + } + + def drop_compiled_net(self) -> None: + """Drop the cached compiled copy, so the next compiled call rebuilds it from the current weights.""" + self._compiled.clear() + + def inference_net(self, compiled: bool) -> Callable[[Tensor, Tensor, Tensor], Tensor]: + """Velocity network used by the ``generate*`` methods. + + Parameters + ---------- + compiled : bool + Return ``torch.compile`` of a channels-last copy of :attr:`net` + (:func:`_channels_last_copy`), built on first use from the current + weights, device and autocast state and reused until + :meth:`drop_compiled_net`; otherwise the network itself. + + Returns + ------- + callable + ``net(xt, cond, t) -> velocity``. + """ + if not compiled: + return self.net + if "net" not in self._compiled: + self._compiled["net"] = torch.compile(_channels_last_copy(self.net), dynamic=False) + return self._compiled["net"] def _noise_like_target(self, phase: Tensor) -> Tensor: """Create Gaussian noise with the network's output channel count. + Drawn from the CPU generator and then moved to ``phase``'s device: a + seeded CUDA ``randn`` gives different numbers on different GPU models + (measured A40 vs H100: two runs of one recipe 0.44 relative L2 apart), + so a seeded prediction would otherwise depend on the GPU it ran on. + Parameters ---------- phase : Tensor @@ -92,9 +302,16 @@ def _noise_like_target(self, phase: Tensor) -> Tensor: """ b, _c, *spatial = phase.shape in_ch = self.net.inconv.in_channels - return torch.randn(b, in_ch, *spatial, device=phase.device, dtype=phase.dtype) + return torch.randn(b, in_ch, *spatial, dtype=phase.dtype).to(phase.device) - def generate(self, phase: Tensor, num_steps: int = 100) -> Tensor: + def generate( + self, + phase: Tensor, + num_steps: int = 100, + sampling_method: str = "dopri5", + time_schedule: str | tuple[float, float] = "uniform", + compiled: bool = False, + ) -> Tensor: """Generate virtual staining via ODE sampling. Parameters @@ -102,7 +319,20 @@ def generate(self, phase: Tensor, num_steps: int = 100) -> Tensor: phase : Tensor Phase contrast input of shape ``(B, 1, D, H, W)``. num_steps : int - Number of ODE integration steps. + Number of ODE output time points; for a fixed-grid + ``sampling_method`` the solver steps on this grid, so it takes + ``num_steps - 1`` steps. + sampling_method : str + ``torchdiffeq`` method: adaptive ``"dopri5"`` (default) or a + fixed-grid one such as ``"euler"``, ``"midpoint"`` or ``"heun2"``. + time_schedule : str or tuple of float + Spacing of the time points, ``"uniform"``, ``"cosine"`` (dense at + both ends, where the velocity field changes fastest) or ``(p, q)`` + for the Beta(p, q) quantiles of a uniform grid (cosine is + Beta(0.5, 0.5)). + compiled : bool + Sample through the compiled copy of the network (see + :meth:`inference_net`). Returns ------- @@ -110,17 +340,26 @@ def generate(self, phase: Tensor, num_steps: int = 100) -> Tensor: Predicted fluorescence of shape ``(B, in_channels, D, H, W)``. """ target = self._noise_like_target(phase) - sample_fn = self.transport_sampler.sample_ode(num_steps=num_steps) + sample_fn = self.transport_sampler.sample_ode( + sampling_method=sampling_method, num_steps=num_steps, time_schedule=time_schedule + ) + net = self.inference_net(compiled) def fn(xt: Tensor, t: Tensor) -> Tensor: - return self.net(xt, phase, t) + return net(xt, phase, t) with torch.no_grad(): target = sample_fn(target, fn)[-1] return target - def generate_trajectory(self, phase: Tensor, num_steps: int = 100) -> Tensor: + def generate_trajectory( + self, + phase: Tensor, + num_steps: int = 100, + sampling_method: str = "dopri5", + time_schedule: str | tuple[float, float] = "uniform", + ) -> Tensor: """Generate virtual staining and return the full ODE trajectory. Parameters @@ -128,7 +367,12 @@ def generate_trajectory(self, phase: Tensor, num_steps: int = 100) -> Tensor: phase : Tensor Phase contrast input of shape ``(B, 1, D, H, W)``. num_steps : int - Number of ODE integration steps. + Number of ODE output time points (trajectory frames). + sampling_method : str + ``torchdiffeq`` method, as in :meth:`generate`. With a fixed-grid + method the frames are the solver's own steps. + time_schedule : str or tuple of float + Spacing of the time points, as in :meth:`generate`. Returns ------- @@ -137,7 +381,9 @@ def generate_trajectory(self, phase: Tensor, num_steps: int = 100) -> Tensor: Index 0 is pure Gaussian noise; index ``-1`` is the final prediction. """ target = self._noise_like_target(phase) - sample_fn = self.transport_sampler.sample_ode(num_steps=num_steps) + sample_fn = self.transport_sampler.sample_ode( + sampling_method=sampling_method, num_steps=num_steps, time_schedule=time_schedule + ) def fn(xt: Tensor, t: Tensor) -> Tensor: return self.net(xt, phase, t) @@ -145,7 +391,14 @@ def fn(xt: Tensor, t: Tensor) -> Tensor: with torch.no_grad(): return sample_fn(target, fn) # (num_steps, B, C, D, H, W) - def generate_sliding_window(self, phase: Tensor, num_steps: int = 100) -> Tensor: + def generate_sliding_window( + self, + phase: Tensor, + num_steps: int = 100, + sampling_method: str = "dopri5", + time_schedule: str | tuple[float, float] = "uniform", + compiled: bool = False, + ) -> Tensor: """Generate virtual staining via tiled sliding window (stride == patch size). Partitions the input into non-overlapping patches of size @@ -160,7 +413,14 @@ def generate_sliding_window(self, phase: Tensor, num_steps: int = 100) -> Tensor phase : Tensor Phase contrast input of shape ``(..., D, H, W)``. num_steps : int - Number of ODE integration steps per patch. + Number of ODE time points per patch; see :meth:`generate`. + sampling_method : str + ``torchdiffeq`` method, as in :meth:`generate`. + time_schedule : str or tuple of float + Spacing of the time points, as in :meth:`generate`. + compiled : bool + Sample through the compiled copy of the network, as in + :meth:`generate`. Returns ------- @@ -170,13 +430,68 @@ def generate_sliding_window(self, phase: Tensor, num_steps: int = 100) -> Tensor spatial = tuple(phase.shape[-3:]) patch_spatial = tuple(self.net.input_spatial_size) n_spatial = 3 + start_lists = window_starts(spatial, patch_spatial, (0, 0, 0)) + + in_ch = self.net.inconv.in_channels + out_shape = (*phase.shape[:-4], in_ch, *phase.shape[-3:]) + out = torch.empty(out_shape, device=phase.device, dtype=phase.dtype) + sample_fn = self.transport_sampler.sample_ode( + sampling_method=sampling_method, num_steps=num_steps, time_schedule=time_schedule + ) + net = self.inference_net(compiled) + + with torch.no_grad(): + for starts in itertools.product(*start_lists): + slicer = [slice(None)] * phase.dim() + for i, st in enumerate(starts): + slicer[-(n_spatial - i)] = slice(st, st + patch_spatial[i]) + phase_patch = phase[tuple(slicer)] + xt = self._noise_like_target(phase_patch) + + def fn( + xt_: Tensor, + t_: Tensor, + _p: Tensor = phase_patch, + ) -> Tensor: + return net(xt_, _p, t_) + + out[tuple(slicer)] = sample_fn(xt, fn)[-1] + + return out + + def generate_sliding_window_trajectory(self, phase: Tensor, num_steps: int = 100) -> Tensor: + """Generate the full ODE trajectory via tiled sliding window (stride == patch size). + + Like :meth:`generate_sliding_window`, but retains **every** ODE + integration step instead of only the final one. Each non-overlapping + patch is integrated independently with fresh Gaussian noise; step ``i`` + is at the same ODE time across all patches, so assembling by step index + yields a spatially-complete volume per step. + + Parameters + ---------- + phase : Tensor + Phase contrast input of shape ``(B, 1, D, H, W)``. + num_steps : int + Number of ODE output time points per patch (trajectory frames). + + Returns + ------- + Tensor + All intermediate ODE states of shape + ``(num_steps, B, in_channels, D, H, W)``. Index 0 is pure Gaussian + noise; index ``-1`` is the final prediction. + """ + spatial = tuple(phase.shape[-3:]) + patch_spatial = tuple(self.net.input_spatial_size) + n_spatial = 3 for i in range(n_spatial): if spatial[i] < patch_spatial[i]: raise ValueError(f"spatial dim {i} ({spatial[i]}) must be >= patch dim ({patch_spatial[i]})") in_ch = self.net.inconv.in_channels - out_shape = (*phase.shape[:-4], in_ch, *phase.shape[-3:]) + out_shape = (num_steps, *phase.shape[:-4], in_ch, *phase.shape[-3:]) out = torch.empty(out_shape, device=phase.device, dtype=phase.dtype) sample_fn = self.transport_sampler.sample_ode(num_steps=num_steps) @@ -203,7 +518,8 @@ def fn( ) -> Tensor: return self.net(xt_, _p, t_) - out[tuple(slicer)] = sample_fn(xt, fn)[-1] + # (num_steps, B, C, pd, ph, pw); prepend step axis to the slicer. + out[(slice(None), *slicer)] = sample_fn(xt, fn) return out @@ -212,6 +528,9 @@ def generate_iterative( phase: Tensor, num_steps: int = 100, overlap_size: int | tuple[int, ...] = 256, + sampling_method: str = "dopri5", + time_schedule: str | tuple[float, float] = "uniform", + compiled: bool = False, ) -> Tensor: """Generate virtual staining via overlapping sliding window with velocity anchoring. @@ -233,16 +552,116 @@ def generate_iterative( phase : Tensor Phase contrast input of shape ``(..., D, H, W)``. num_steps : int - Number of ODE integration steps per patch. + Number of ODE time points per patch; see :meth:`generate`. overlap_size : int or tuple of int Overlap in each spatial dimension ``(od, oh, ow)``. A single int applies the same overlap to all three dimensions. + sampling_method : str + ``torchdiffeq`` method, as in :meth:`generate`. + time_schedule : str or tuple of float + Spacing of the time points, as in :meth:`generate`. + compiled : bool + Sample through the compiled copy of the network, as in + :meth:`generate`. Returns ------- Tensor Predicted fluorescence of shape ``(..., D, H, W)``. + Raises + ------ + NotImplementedError + If ``path_type`` is not ``"Linear"`` or ``prediction`` is not + ``"velocity"``, since the anchoring formula is path-specific. + """ + if self.path_type != "Linear" or self.prediction != "velocity": + raise NotImplementedError( + "generate_iterative only supports Linear path with velocity prediction, " + f"got path_type={self.path_type!r}, prediction={self.prediction!r}" + ) + + spatial = tuple(phase.shape[-3:]) + patch_spatial = tuple(self.net.input_spatial_size) + n_spatial = 3 + start_lists = window_starts(spatial, patch_spatial, overlap_size) + + in_ch = self.net.inconv.in_channels + out_shape = (*phase.shape[:-4], in_ch, *phase.shape[-3:]) + out = torch.full(out_shape, float("nan"), device=phase.device, dtype=phase.dtype) + sample_fn = self.transport_sampler.sample_ode( + sampling_method=sampling_method, num_steps=num_steps, time_schedule=time_schedule + ) + net = self.inference_net(compiled) + + with torch.no_grad(): + for starts in itertools.product(*start_lists): + slicer = [slice(None)] * phase.dim() + for i, st in enumerate(starts): + slicer[-(n_spatial - i)] = slice(st, st + patch_spatial[i]) + + phase_patch = phase[tuple(slicer)] + out_patch = out[tuple(slicer)].clone() + xt = self._noise_like_target(phase_patch) + known_mask = ~torch.isnan(out_patch) + + def fn( + xt_: Tensor, + t_: Tensor, + _p: Tensor = phase_patch, + _out: Tensor = out_patch, + _mask: Tensor = known_mask, + ) -> Tensor: + v = net(xt_, _p, t_) + # Infer x0 from the Linear-path formula: x0 = xt - t*v. + t_exp = t_.reshape(t_.shape[0], *([1] * (xt_.dim() - 1))) + x0_ = xt_ - t_exp * v + # Velocity that integrates x0 exactly to the known target: v = x1 - x0. + v_out = _out - x0_ + # Use the anchored velocity in the overlap region, free velocity elsewhere. + return torch.where(_mask, v_out, v) + + patch_out = sample_fn(xt, fn)[-1] + out[tuple(slicer)] = patch_out + + return out + + def generate_iterative_trajectory( + self, + phase: Tensor, + num_steps: int = 100, + overlap_size: int | tuple[int, ...] = 256, + ) -> Tensor: + """Generate the full ODE trajectory via overlapping sliding window with velocity anchoring. + + Like :meth:`generate_iterative`, but retains **every** ODE integration + step instead of only the final one. Patches are still processed + sequentially; each patch's overlap region is anchored toward the + **final** output of previously-completed patches (identical anchoring to + :meth:`generate_iterative`), and the whole per-step trajectory of each + patch is written into the output. Overlapping voxels are last-write-wins + across patches, matching :meth:`generate_iterative`. Step ``i`` is at the + same ODE time across all patches, so assembling by step index yields a + spatially-complete volume per step. + + Parameters + ---------- + phase : Tensor + Phase contrast input of shape ``(B, 1, D, H, W)``. + num_steps : int + Number of ODE output time points per patch (trajectory frames). + overlap_size : int or tuple of int + Overlap in each spatial dimension ``(od, oh, ow)``. + A single int applies the same overlap to all three dimensions. + + Returns + ------- + Tensor + All intermediate ODE states of shape + ``(num_steps, B, in_channels, D, H, W)``. Index 0 is pure Gaussian + noise; index ``-1`` is the final prediction (equal to + :meth:`generate_iterative`). + Raises ------ NotImplementedError @@ -269,13 +688,17 @@ def generate_iterative( if self.path_type != "Linear" or self.prediction != "velocity": raise NotImplementedError( - "generate_iterative only supports Linear path with velocity prediction, " + "generate_iterative_trajectory only supports Linear path with velocity prediction, " f"got path_type={self.path_type!r}, prediction={self.prediction!r}" ) in_ch = self.net.inconv.in_channels out_shape = (*phase.shape[:-4], in_ch, *phase.shape[-3:]) + # `out` holds the FINAL values used for anchoring (as in generate_iterative); + # `out_traj` accumulates every ODE step across the whole volume. out = torch.full(out_shape, float("nan"), device=phase.device, dtype=phase.dtype) + traj_shape = (num_steps, *out_shape) + out_traj = torch.empty(traj_shape, device=phase.device, dtype=phase.dtype) sample_fn = self.transport_sampler.sample_ode(num_steps=num_steps) start_lists: list[list[int]] = [] @@ -320,10 +743,153 @@ def fn( # Use the anchored velocity in the overlap region, free velocity elsewhere. return torch.where(_mask, v_out, v) - patch_out = sample_fn(xt, fn)[-1] - out[tuple(slicer)] = patch_out + traj = sample_fn(xt, fn) # (num_steps, B, C, pd, ph, pw) + out_traj[(slice(None), *slicer)] = traj + out[tuple(slicer)] = traj[-1] - return out + return out_traj + + def generate_iterative_denoise_trajectory( + self, + phase: Tensor, + num_steps: int = 100, + overlap_size: int | tuple[int, ...] = 256, + ) -> Tensor: + """Return the per-step denoised clean-target estimate ``x1`` of the iterative ODE. + + Runs the identical overlapping-window, velocity-anchored ODE integration + as :meth:`generate_iterative` (the underlying prediction is unchanged), + but at every returned ODE node ``i`` records the network's **denoised + estimate of the clean target** rather than the raw ODE state ``xt``. + + For the Linear path with velocity prediction the flow satisfies + ``xt = (1 - t) * x0 + t * x1`` with velocity ``v = x1 - x0``. Solving for + the clean target gives + + ``x1 = xt + (1 - t) * v`` + + which is the exact complement of the noise estimate ``x0 = xt - t * v`` + used for anchoring in :meth:`generate_iterative`. ``v`` here is the + **raw** network velocity ``net(xt, phase, t)`` (not the anchored velocity + used to drive the solver). At ``t = 0`` (step 1) this is the one-step + denoise-from-noise estimate; at ``t = 1`` (last step) ``(1 - t) = 0`` so + the estimate equals the final ODE state, i.e. the final prediction. + + Parameters + ---------- + phase : Tensor + Phase contrast input of shape ``(B, 1, D, H, W)``. + num_steps : int + Number of ODE output time points per patch (trajectory frames). + overlap_size : int or tuple of int + Overlap in each spatial dimension ``(od, oh, ow)``. + A single int applies the same overlap to all three dimensions. + + Returns + ------- + Tensor + Per-step clean-target estimates of shape + ``(num_steps, B, in_channels, D, H, W)``. Index 0 is the one-step + denoise-from-noise estimate; index ``-1`` equals the final prediction. + + Raises + ------ + NotImplementedError + If ``path_type`` is not ``"Linear"`` or ``prediction`` is not + ``"velocity"``, since the ``x1`` formula is path-specific. + """ + spatial = tuple(phase.shape[-3:]) + patch_spatial = tuple(self.net.input_spatial_size) + n_spatial = 3 + + if isinstance(overlap_size, int): + overlap = (overlap_size,) * n_spatial + else: + overlap = tuple(overlap_size) + if len(overlap) != n_spatial: + raise ValueError("overlap_size must be int or a 3-tuple") + + for i in range(n_spatial): + s_i, p_i, ov = spatial[i], patch_spatial[i], overlap[i] + if s_i < p_i: + raise ValueError(f"spatial dim {i} ({s_i}) must be >= patch dim ({p_i})") + if not (0 <= ov < p_i): + raise ValueError(f"overlap at dim {i} must satisfy 0 <= overlap < patch (got {ov} vs patch {p_i})") + + if self.path_type != "Linear" or self.prediction != "velocity": + raise NotImplementedError( + "generate_iterative_denoise_trajectory only supports Linear path with velocity " + f"prediction, got path_type={self.path_type!r}, prediction={self.prediction!r}" + ) + + in_ch = self.net.inconv.in_channels + out_shape = (*phase.shape[:-4], in_ch, *phase.shape[-3:]) + # `out` holds the FINAL values used for anchoring (as in generate_iterative); + # `out_traj` accumulates the per-step x1 (clean-target) estimate. + out = torch.full(out_shape, float("nan"), device=phase.device, dtype=phase.dtype) + traj_shape = (num_steps, *out_shape) + out_traj = torch.empty(traj_shape, device=phase.device, dtype=phase.dtype) + sample_fn = self.transport_sampler.sample_ode(num_steps=num_steps) + # ODE node times for the Linear+velocity config: linspace(0, 1, num_steps). + t_grid = torch.linspace(0.0, 1.0, num_steps, device=phase.device, dtype=phase.dtype) + + start_lists: list[list[int]] = [] + for i in range(n_spatial): + s_i, p_i, ov = spatial[i], patch_spatial[i], overlap[i] + stride = p_i - ov + last = s_i - p_i + starts = [0] + while True: + nxt = starts[-1] + stride + if nxt >= last: + break + starts.append(nxt) + if starts[-1] != last: + starts.append(last) + start_lists.append(starts) + + with torch.no_grad(): + for starts in itertools.product(*start_lists): + slicer = [slice(None)] * phase.dim() + for i, st in enumerate(starts): + slicer[-(n_spatial - i)] = slice(st, st + patch_spatial[i]) + + phase_patch = phase[tuple(slicer)] + out_patch = out[tuple(slicer)].clone() + xt = self._noise_like_target(phase_patch) + known_mask = ~torch.isnan(out_patch) + batch_size = phase_patch.shape[0] + + def fn( + xt_: Tensor, + t_: Tensor, + _p: Tensor = phase_patch, + _out: Tensor = out_patch, + _mask: Tensor = known_mask, + ) -> Tensor: + v = self.net(xt_, _p, t_) + # Infer x0 from the Linear-path formula: x0 = xt - t*v. + t_exp = t_.reshape(t_.shape[0], *([1] * (xt_.dim() - 1))) + x0_ = xt_ - t_exp * v + # Velocity that integrates x0 exactly to the known target: v = x1 - x0. + v_out = _out - x0_ + # Use the anchored velocity in the overlap region, free velocity elsewhere. + return torch.where(_mask, v_out, v) + + # Raw ODE state trajectory (drives the prediction, kept for anchoring). + traj = sample_fn(xt, fn) # (num_steps, B, C, pd, ph, pw) + + # Per node, the clean-target estimate x1 = xt + (1 - t) * v with the RAW + # network velocity at that node (re-evaluated; dopri5 nodes are dense-output + # interpolants at t_grid, so this is the true velocity field at each node). + for i in range(num_steps): + t_i = t_grid[i] + v_i = self.net(traj[i], phase_patch, t_i.expand(batch_size)) + out_traj[(i, *slicer)] = traj[i] + (1.0 - t_i) * v_i + + out[tuple(slicer)] = traj[-1] + + return out_traj def denoise_sliding_window( self, @@ -359,38 +925,13 @@ def denoise_sliding_window( spatial = tuple(phase.shape[-3:]) patch_spatial = tuple(self.net.input_spatial_size) n_spatial = 3 - - if isinstance(overlap_size, int): - overlap = (overlap_size,) * n_spatial - else: - overlap = tuple(overlap_size) - if len(overlap) != n_spatial: - raise ValueError("overlap_size must be int or a 3-tuple") - - for i in range(n_spatial): - S, P, Ov = spatial[i], patch_spatial[i], overlap[i] - if S < P: - raise ValueError(f"spatial dim {i} ({S}) must be >= patch dim ({P})") - if not (0 <= Ov < P): - raise ValueError(f"overlap at dim {i} must satisfy 0 <= overlap < patch (got {Ov} vs {P})") + start_lists = window_starts(spatial, patch_spatial, overlap_size) in_ch = self.net.inconv.in_channels out_shape = (*phase.shape[:-4], in_ch, *phase.shape[-3:]) prediction_sum = torch.zeros(out_shape, device=phase.device, dtype=phase.dtype) prediction_count = torch.zeros(out_shape, device=phase.device, dtype=phase.dtype) - start_lists: list[list[int]] = [] - for i in range(n_spatial): - S, P, Ov = spatial[i], patch_spatial[i], overlap[i] - stride = P - Ov - last = S - P - starts = [0] - while starts[-1] + stride < last: - starts.append(starts[-1] + stride) - if starts[-1] != last: - starts.append(last) - start_lists.append(starts) - with torch.no_grad(): for starts in itertools.product(*start_lists): slicer = [slice(None)] * phase.dim() diff --git a/applications/dynacell/src/dynacell/collections/__init__.py b/applications/dynacell/src/dynacell/collections/__init__.py new file mode 100644 index 000000000..a1eecb2fa --- /dev/null +++ b/applications/dynacell/src/dynacell/collections/__init__.py @@ -0,0 +1,20 @@ +"""Frozen benchmark collections: schema access + freeze/show/validate.""" + +from dynacell.collections.freezer import ( + ExperimentSelector, + freeze_collection, +) +from dynacell.collections.registry import ( + get_collection, + list_collections, +) +from dynacell.data import BenchmarkCollection, load_collection + +__all__ = [ + "BenchmarkCollection", + "ExperimentSelector", + "freeze_collection", + "get_collection", + "list_collections", + "load_collection", +] diff --git a/applications/dynacell/src/dynacell/collections/freezer.py b/applications/dynacell/src/dynacell/collections/freezer.py new file mode 100644 index 000000000..915be9d9a --- /dev/null +++ b/applications/dynacell/src/dynacell/collections/freezer.py @@ -0,0 +1,324 @@ +"""Snapshot ``(dataset, target)`` selectors into a frozen ``BenchmarkCollection`` YAML. + +The freezer reads ground-truth channel names and FOV membership from +the train/test zarr stores (not from the manifest), so the resulting +collection describes what is actually on disk at freeze time. +""" + +from dataclasses import dataclass +from datetime import UTC, datetime +from pathlib import Path + +import yaml # type: ignore[import-untyped] +from iohub.ngff import open_ome_zarr + +from dynacell.data import ( + BenchmarkCollection, + TargetConfig, + VoxelSpacing, + get_manifest, +) +from dynacell.data.collections import CollectionExperiment, Provenance +from viscy_data.collection import ChannelEntry + +_STORE_ROLES: tuple[str, ...] = ("train", "test") + + +@dataclass(frozen=True, slots=True) +class ExperimentSelector: + """One ``(dataset, target)`` entry in a freeze request. + + Parameters + ---------- + dataset + Registered dataset key (e.g. ``"aics-hipsc"``, + ``"a549-mantis-2024_11_07"``). + target + Target name within the dataset manifest (e.g. ``"sec61b"``). + include_train + If ``False``, skip this selector's train store during freeze. + include_test + If ``False``, skip this selector's test store during freeze. + condition + If set, keep only positions whose ``.zattrs["condition"]`` equals + this value. Used to author condition-filtered joint collections + (e.g. ``"mock"`` for uninfected-only A549 regimes). When ``None``, + every position in the referenced store contributes. + """ + + dataset: str + target: str + include_train: bool = True + include_test: bool = True + condition: str | None = None + + +def _dataset_short_name(dataset: str) -> str: + """Derive an experiment-name-safe short tag from a dataset key. + + ``aics-hipsc`` becomes ``hipsc``; ``a549-mantis`` becomes + ``a549_mantis``. The short tag is embedded in experiment names so + joint collections (multiple datasets, same target) disambiguate + cleanly. + """ + stem = dataset.removeprefix("aics-") + return stem.replace("-", "_") + + +def freeze_collection( + experiments: list[ExperimentSelector], + output_path: Path, + *, + created_by: str, + created_at: str | None = None, + mirror_path: Path | None = None, + description: str | None = None, +) -> BenchmarkCollection: + """Freeze a list of selectors into a YAML collection file. + + Parameters + ---------- + experiments + One or more ``ExperimentSelector`` instances. Each selector + contributes up to two stores (train and test) to the collection, + controlled by its ``include_train`` / ``include_test`` flags. + output_path + Canonical YAML location to write (typically + ``configs/collections/virtual_staining/.yaml``). The + collection's ``name`` field is derived from ``output_path.stem``, + so the filename must match the intended collection name. + created_by + Author attribution stored in ``provenance.created_by``. Required. + created_at + ISO-8601 timestamp for ``provenance.created_at``. Defaults to + ``datetime.now(tz=UTC).isoformat()``. Accept an explicit value + to reproduce an existing collection byte-for-byte. + mirror_path + Optional second path to receive the byte-identical YAML (used + for the packaged ``dynacell/_configs/collections/`` mirror). + description + Optional collection description. When ``None``, a default is + derived from the selectors by :func:`_resolve_description`. + + Returns + ------- + BenchmarkCollection + The validated collection that was written. + + Raises + ------ + ValueError + If ``experiments`` is empty, contains exact duplicate selectors, + contains a no-op selector with both include flags disabled, + would emit the same ``(dataset, target, role)`` from more than + one selector (which would produce duplicate experiment names), + or contributes no experiments at all because every requested + role resolved to a missing store. + """ + if not experiments: + raise ValueError("experiments must be non-empty") + if len(set(experiments)) != len(experiments): + raise ValueError("duplicate ExperimentSelector in experiments list") + for sel in experiments: + if not sel.include_train and not sel.include_test: + raise ValueError( + f"selector {sel!r} has both include_train=False and include_test=False; drop the selector instead" + ) + seen_contributions: set[tuple[str, str, str]] = set() + for sel in experiments: + for role in _STORE_ROLES: + if role == "train" and not sel.include_train: + continue + if role == "test" and not sel.include_test: + continue + key = (sel.dataset, sel.target, role) + if key in seen_contributions: + raise ValueError( + "selectors contribute the same " + f"(dataset={sel.dataset!r}, target={sel.target!r}, " + f"role={role!r}) more than once" + ) + seen_contributions.add(key) + + collection_experiments: list[CollectionExperiment] = [] + train_fovs: list[str] = [] + test_fovs: list[str] = [] + + for sel in experiments: + manifest = get_manifest(sel.dataset) + short = _dataset_short_name(sel.dataset) + target_cfg = manifest.targets[sel.target] + for role in _STORE_ROLES: + if role == "train" and not sel.include_train: + continue + if role == "test" and not sel.include_test: + continue + store_path = getattr(target_cfg.stores, role, None) + if store_path is None: + continue + experiment_name = f"{sel.target}_{short}_{role}" + experiment, fovs = _snapshot_store( + store_path=Path(store_path), + experiment_name=experiment_name, + target_cfg=target_cfg, + manifest_spacing=manifest.spacing, + condition_filter=sel.condition, + ) + collection_experiments.append(experiment) + if role == "train": + train_fovs.extend(fovs) + else: + test_fovs.extend(fovs) + + if not collection_experiments: + pairs = ", ".join(f"({sel.dataset!r}, {sel.target!r})" for sel in experiments) + raise ValueError( + f"selectors [{pairs}] contributed no experiments: every requested role was either disabled by an " + "include flag or absent from the manifest. Eval-only datasets (e.g. 'hek-mantis-*') carry " + "stores.train=None, so a selector with include_test=False leaves nothing to snapshot. An empty " + "collection would pass validation and then break downstream FOV lookup, which indexes experiments " + "by name." + ) + + names = [exp.name for exp in collection_experiments] + if len(set(names)) != len(names): + raise ValueError( + f"duplicate CollectionExperiment.name in {names!r}; downstream FOV validation indexes experiments by name" + ) + + provenance = Provenance( + created_at=created_at or datetime.now(tz=UTC).isoformat(), + created_by=created_by, + record_ids=[], + ) + collection = BenchmarkCollection( + name=output_path.stem, + description=description or _resolve_description(experiments), + provenance=provenance, + experiments=collection_experiments, + train_fovs=train_fovs or None, + test_fovs=test_fovs or None, + ) + + payload = yaml.safe_dump( + collection.model_dump(mode="json"), + sort_keys=False, + default_flow_style=False, + ) + output_path.parent.mkdir(parents=True, exist_ok=True) + output_path.write_text(payload) + if mirror_path is not None: + mirror_path.parent.mkdir(parents=True, exist_ok=True) + mirror_path.write_text(payload) + + return collection + + +def _resolve_description(experiments: list[ExperimentSelector]) -> str: + """Pick a default description when the caller didn't supply one. + + When every selector shares one ``(dataset, target)`` pair, delegate + to :func:`_default_description` with those scalars so single-selector + freezes reproduce the pre-A2 template byte-for-byte. Multi-source + single-target and multi-target collections get their own deterministic + templates. If every condition-filtered selector agrees on one + ``condition`` value, the template names the filter so downstream + readers can identify mock-only / DENV-only / etc. collections at a + glance. + """ + pairs = {(s.dataset, s.target) for s in experiments} + if len(pairs) == 1: + dataset, target = next(iter(pairs)) + return _default_description(dataset, target) + conditions = {s.condition for s in experiments if s.condition is not None} + condition_note = "" + if len(conditions) == 1: + (only_condition,) = conditions + condition_note = f" with condition filter {only_condition!r}" + targets = sorted({s.target for s in experiments}) + if len(targets) == 1: + datasets = sorted({s.dataset for s in experiments}) + return ( + f"Joint frozen benchmark collection for target {targets[0]!r}" + f"{condition_note} across {len(datasets)} source datasets. " + "Channels and FOV membership captured from the live train/test " + "zarr stores at freeze time." + ) + return ( + f"Joint frozen benchmark collection{condition_note} across " + f"{len(experiments)} selectors covering targets " + f"{', '.join(repr(t) for t in targets)}. " + "Channels and FOV membership captured from the live train/test " + "zarr stores at freeze time." + ) + + +def _snapshot_store( + store_path: Path, + experiment_name: str, + target_cfg: TargetConfig, + manifest_spacing: VoxelSpacing, + condition_filter: str | None = None, +) -> tuple[CollectionExperiment, list[str]]: + """Open one HCS zarr and capture channels + positions. + + Sorts positions lexicographically so fresh freezes reproduce + committed YAMLs byte-for-byte. Asserts channel lists are + consistent across positions. When ``condition_filter`` is set, + keeps only positions whose ``.zattrs["condition"]`` matches; raises + if no position carries the ``condition`` attr (wrong store) or if + the filter removes every position (empty selector). + """ + with open_ome_zarr(store_path, mode="r") as plate: + positions = sorted(plate.positions(), key=lambda pair: pair[0]) + if not positions: + raise ValueError(f"No positions in {store_path}") + if condition_filter is not None: + annotated = [(name, pos) for name, pos in positions if "condition" in pos.zattrs] + if not annotated: + raise ValueError( + f"Selector requested condition={condition_filter!r} but no " + f"position in {store_path} carries a 'condition' zattr" + ) + positions = [(name, pos) for name, pos in annotated if pos.zattrs["condition"] == condition_filter] + if not positions: + raise ValueError( + f"Condition filter {condition_filter!r} matched 0 " + f"positions in {store_path}; drop the selector or " + "pick a condition present in this store" + ) + channel_names = list(positions[0][1].channel_names) + for name, pos in positions[1:]: + if list(pos.channel_names) != channel_names: + raise ValueError( + f"Channel drift in {store_path}: {name} has {list(pos.channel_names)}, expected {channel_names}" + ) + fov_names = [name for name, _ in positions] + + channels = [ + ChannelEntry( + name=ch, + marker=target_cfg.gene if ch == target_cfg.target_channel else ch, + ) + for ch in channel_names + ] + experiment = CollectionExperiment( + name=experiment_name, + data_path=store_path, + channels=channels, + organelle=target_cfg.organelle, + marker=target_cfg.gene, + pixel_size_xy_um=manifest_spacing.x, + pixel_size_z_um=manifest_spacing.z, + ) + prefixed = [f"{experiment_name}/{fov}" for fov in fov_names] + return experiment, prefixed + + +def _default_description(dataset: str, target: str) -> str: + """Write a short human-readable description for a single-pair collection.""" + return ( + f"Frozen benchmark collection for {dataset!r} target {target!r}. " + "Channels and FOV membership captured from the live train/test " + "zarr stores at freeze time." + ) diff --git a/applications/dynacell/src/dynacell/collections/registry.py b/applications/dynacell/src/dynacell/collections/registry.py new file mode 100644 index 000000000..b34974f78 --- /dev/null +++ b/applications/dynacell/src/dynacell/collections/registry.py @@ -0,0 +1,71 @@ +"""Collection registry: name -> YAML path mapping and loading. + +Mirrors :mod:`dynacell.data.registry`. Uses a hardcoded dict +instead of a filesystem walk so a duplicate or malformed YAML does +not break every consumer at import time. + +Import is side-effect-free for the same reason: the packaged YAMLs are +only touched by :func:`get_collection`, so an incomplete install cannot +make this module — or the sibling :mod:`dynacell.collections.freezer`, +re-exported from the same package — unimportable. The freezer is what +regenerates missing collection YAMLs, so it must stay reachable when +they are absent. +""" + +from importlib.resources import files +from pathlib import Path + +from dynacell.data import BenchmarkCollection, load_collection + +_CONFIGS_ROOT = Path(str(files("dynacell") / "_configs" / "collections")) + +_REGISTRY: dict[str, Path] = { + "sec61b_ipsc_v1": _CONFIGS_ROOT / "virtual_staining" / "sec61b_ipsc_v1.yaml", + "sec61b_joint_all_v1": _CONFIGS_ROOT / "virtual_staining" / "sec61b_joint_all_v1.yaml", + "sec61b_joint_mock_v1": _CONFIGS_ROOT / "virtual_staining" / "sec61b_joint_mock_v1.yaml", + "tomm20_joint_all_v1": _CONFIGS_ROOT / "virtual_staining" / "tomm20_joint_all_v1.yaml", + "tomm20_joint_mock_v1": _CONFIGS_ROOT / "virtual_staining" / "tomm20_joint_mock_v1.yaml", + "nucleus_ipsc_v1": _CONFIGS_ROOT / "virtual_staining" / "nucleus_ipsc_v1.yaml", + "nucleus_joint_all_v1": _CONFIGS_ROOT / "virtual_staining" / "nucleus_joint_all_v1.yaml", + "nucleus_joint_mock_v1": _CONFIGS_ROOT / "virtual_staining" / "nucleus_joint_mock_v1.yaml", + "membrane_ipsc_v1": _CONFIGS_ROOT / "virtual_staining" / "membrane_ipsc_v1.yaml", + "membrane_joint_all_v1": _CONFIGS_ROOT / "virtual_staining" / "membrane_joint_all_v1.yaml", + "membrane_joint_mock_v1": _CONFIGS_ROOT / "virtual_staining" / "membrane_joint_mock_v1.yaml", +} + + +def list_collections() -> list[str]: + """Return all registered collection names.""" + return list(_REGISTRY.keys()) + + +def get_collection(name: str) -> BenchmarkCollection: + """Load and validate a frozen benchmark collection by name. + + Parameters + ---------- + name + Key in the registry, e.g. ``"sec61b_ipsc_v1"``. + + Returns + ------- + BenchmarkCollection + Validated collection. + + Raises + ------ + KeyError + If the collection name is not registered. + FileNotFoundError + If the collection is registered but its packaged YAML is absent, + which means the install is incomplete. + """ + if name not in _REGISTRY: + raise KeyError(f"Unknown collection {name!r}. Available: {list_collections()}") + path = _REGISTRY[name] + if not path.is_file(): + raise FileNotFoundError( + f"Collection {name!r} is registered but its YAML is missing at {path}. " + "The packaged configs are incomplete — reinstall dynacell: uv sync" + ) + return load_collection(path) diff --git a/applications/dynacell/src/dynacell/croissant/__init__.py b/applications/dynacell/src/dynacell/croissant/__init__.py new file mode 100644 index 000000000..64e25b1db --- /dev/null +++ b/applications/dynacell/src/dynacell/croissant/__init__.py @@ -0,0 +1,23 @@ +"""Croissant 1.1 RAI metadata generation for DynaCell release trees. + +Builds a single JSON-LD descriptor per release dataset by scanning the +packed OZX archives directly. The generated JSON-LD validates against +the ML Commons Croissant 1.1 schema and the RAI extension fields +required by NeurIPS Evaluations & Datasets. +""" + +from dynacell.croissant.builder import ( + build_croissant_from_release, + merge_croissant_docs, +) +from dynacell.croissant.static import StaticFields + +# ``validate_croissant`` is deliberately NOT re-exported here: its module imports +# mlcroissant at top level, so an eager re-export makes the optional ``croissant`` +# extra a hard requirement for ``builder`` too -- defeating cli.py's lazy imports +# and the --no-validate flag. Import it from dynacell.croissant.validate directly. +__all__ = [ + "StaticFields", + "build_croissant_from_release", + "merge_croissant_docs", +] diff --git a/applications/dynacell/src/dynacell/croissant/builder.py b/applications/dynacell/src/dynacell/croissant/builder.py new file mode 100644 index 000000000..01bf74552 --- /dev/null +++ b/applications/dynacell/src/dynacell/croissant/builder.py @@ -0,0 +1,460 @@ +"""Croissant 1.1 JSON-LD builder for a packed release tree. + +Scans ``/data//{train,test}/*.ozx``, opens +each store via ``iohub`` to read FOV/channel/voxel metadata, and emits a +single Croissant document covering the whole release dataset. +""" + +from pathlib import Path +from typing import Any + +from dynacell.croissant.static import StaticFields + +__all__ = [ + "build_croissant_from_release", + "merge_croissant_docs", + "CROISSANT_CONTEXT", +] + + +CROISSANT_CONTEXT: dict[str, Any] = { + "@language": "en", + "@vocab": "https://schema.org/", + "citeAs": "cr:citeAs", + "column": "cr:column", + "conformsTo": "dct:conformsTo", + "cr": "http://mlcommons.org/croissant/", + "data": {"@id": "cr:data", "@type": "@json"}, + "dataType": {"@id": "cr:dataType", "@type": "@vocab"}, + "dct": "http://purl.org/dc/terms/", + "equivalentProperty": "cr:equivalentProperty", + "examples": {"@id": "cr:examples", "@type": "@json"}, + "extract": "cr:extract", + "field": "cr:field", + "fileProperty": "cr:fileProperty", + "fileObject": "cr:fileObject", + "fileSet": "cr:fileSet", + "format": "cr:format", + "includes": "cr:includes", + "isLiveDataset": "cr:isLiveDataset", + "jsonPath": "cr:jsonPath", + "key": "cr:key", + "md5": "cr:md5", + "parentField": "cr:parentField", + "path": "cr:path", + "rai": "http://mlcommons.org/croissant/RAI/", + "prov": "http://www.w3.org/ns/prov#", + "recordSet": "cr:recordSet", + "references": "cr:references", + "regex": "cr:regex", + "repeated": "cr:repeated", + "replace": "cr:replace", + "samplingRate": "cr:samplingRate", + "sc": "https://schema.org/", + "separator": "cr:separator", + "source": "cr:source", + "subField": "cr:subField", + "transform": "cr:transform", +} + + +# Map from assembly_target → (gene, organelle, channel_label) +_TARGET_META: dict[str, tuple[str, str, str]] = { + "h2b": ("H2B", "nucleus", "Nuclei"), + "caax": ("CAAX", "membrane", "Membrane"), + "sec61b": ("SEC61B", "endoplasmic reticulum", "Structure"), + "tomm20": ("TOMM20", "mitochondria", "Structure"), +} + + +def _format_shape(shape_min: list[int], shape_max: list[int]) -> str: + """Render a store's shape, showing a range on any axis that varies. + + Parameters + ---------- + shape_min, shape_max : list of int + Per-axis minimum and maximum over every position in the store. + + Returns + ------- + str + e.g. ``"[10, 3, 48, 640, 960]"`` when all positions agree, or + ``"[7-10, 3, 48, 640, 960]"`` when T varies. Heterogeneous T is by + design in the A549 pools, so collapsing it to one number would state + something false about half the FOVs in a published document. + """ + return "[" + ", ".join(str(lo) if lo == hi else f"{lo}-{hi}" for lo, hi in zip(shape_min, shape_max)) + "]" + + +def _scan_ozx_tree( + release_root: Path, + dataset_prefix: str, +) -> list[dict[str, Any]]: + """Walk ``/data//{train,test}/*.ozx``. + + Opens each OZX via ``iohub.open_ome_zarr`` and extracts root- and + FOV-level metadata. Returns one dict per store with keys: + ``file``, ``split``, ``target``, ``condition``, ``n_fov``, ``shape``, + ``channels``, ``voxel_size``, ``size_bytes``, ``abs_path``. + """ + import os + + from iohub import open_ome_zarr + + data_dir = release_root / "data" / dataset_prefix + entries: list[dict[str, Any]] = [] + for split in ("train", "test"): + split_dir = data_dir / split + if not split_dir.is_dir(): + continue + for fname in sorted(os.listdir(split_dir)): + if not fname.endswith(".ozx"): + continue + ozx_path = split_dir / fname + with open_ome_zarr(str(ozx_path), mode="r") as ds: + root_attrs = dict(ds.zattrs) + positions = list(ds.positions()) + if not positions: + raise ValueError(f"OZX store has no positions: {ozx_path}") + first_pos_key = positions[0][0] + # Shape is published as a store-wide claim, so read every + # position rather than position 0. Heterogeneous T is by design + # in these pools -- a549-mantis-sec61b-mock train really does + # hold 14 FOVs at T=7 and 14 at T=10 -- so a single-position + # probe states one shape for a store where half the FOVs differ. + shapes = [list(ds[name + "/0"].shape) for name, _ in positions] + if len({len(sh) for sh in shapes}) != 1: + raise ValueError(f"positions disagree on rank in {ozx_path}: {sorted({len(sh) for sh in shapes})}") + shape_min = [min(sh[a] for sh in shapes) for a in range(len(shapes[0]))] + shape_max = [max(sh[a] for sh in shapes) for a in range(len(shapes[0]))] + if shape_min[1] != shape_max[1]: + raise ValueError( + f"positions disagree on channel count in {ozx_path}: " + f"{shape_min[1]}..{shape_max[1]}; channels are a store-level property" + ) + omero = ds[first_pos_key].zattrs["ome"]["omero"] + channels = [ch["label"] for ch in omero["channels"]] + multiscales = ds[first_pos_key].zattrs["ome"]["multiscales"][0] + # OZX may carry a {type: scale, scale: [...]} transform, + # an {type: identity} transform with no spacing, or omit + # transforms entirely. Take the first scale transform if + # present; otherwise leave voxel_size None so the doc + # omits the spacing line rather than emitting wrong values. + voxel_size: list[float] | None = None + for tr in multiscales["datasets"][0].get("coordinateTransformations", []): + if tr.get("type") == "scale": + voxel_size = tr["scale"] # [T, C, Z, Y, X] + break + stem = fname.removesuffix(".ozx") + if "_" in stem: + fallback_target, fallback_condition = stem.split("_", 1) + else: + # iPSC convention: .ozx with no perturbation suffix. + fallback_target, fallback_condition = stem, "none" + entries.append( + { + "file": fname, + "split": split, + "target": root_attrs.get("assembly_target", fallback_target.lower()), + "condition": root_attrs.get("assembly_condition", fallback_condition), + "n_fov": len(positions), + "shape_min": shape_min, + "shape_max": shape_max, + "channels": channels, + "voxel_size": voxel_size, + "size_bytes": ozx_path.stat().st_size, + "abs_path": str(ozx_path), + } + ) + return entries + + +def build_croissant_from_release( + release_root: Path, + static: StaticFields, + dataset_prefix: str = "biohub-a549", + compute_sha256: bool = False, +) -> dict[str, Any]: + """Build a Croissant 1.1 JSON-LD by scanning packed OZX stores. + + Derives all metadata directly from the OZX archives via ``iohub`` — + no dataset manifests or config YAMLs required. Suitable for + generating Croissant after data has been packed and synced. + + Parameters + ---------- + release_root + Root of the release tree (e.g. ``/hpc/projects/.../dynacell_v1``). + Expects ``data//{train,test}/*.ozx`` underneath. + static + Authoring constants (license, citation, RAI prose). + dataset_prefix + Subdirectory under ``data/`` to scan (default ``"biohub-a549"``). + compute_sha256 + If True, compute SHA-256 of each OZX file. Slow for large + archives (~400 GB total); default False. + + Returns + ------- + dict + JSON-LD-encodable Croissant 1.1 document. + """ + import hashlib + + entries = _scan_ozx_tree(release_root, dataset_prefix) + if not entries: + raise FileNotFoundError(f"No .ozx files found under {release_root / 'data' / dataset_prefix}") + + # Emit s3:// as primary contentUrl (canonical store identifier; what + # AWS-CLI / boto3 consume directly) and the HTTPS URI in sameAs for + # browser / curl convenience. Both resolve to identical bytes. + # Region-explicit hostname (AWS Open Data canonical form, per the datasheet). + https_base = f"https://{static.aws_bucket}.s3.us-west-2.amazonaws.com/{static.aws_prefix}/data/{dataset_prefix}" + s3_base = f"s3://{static.aws_bucket}/{static.aws_prefix}/data/{dataset_prefix}" + + file_objects: list[dict[str, Any]] = [] + for e in entries: + sha256 = "" + if compute_sha256: + h = hashlib.sha256() + with open(e["abs_path"], "rb") as f: + for chunk in iter(lambda: f.read(1 << 20), b""): + h.update(chunk) + sha256 = h.hexdigest() + + file_objects.append( + { + "@type": "cr:FileObject", + "@id": (f"{dataset_prefix}/{e['split']}/{e['file'].replace('.ozx', '')}"), + "name": e["file"], + "description": ( + f"OZX-packed OME-Zarr for {e['target']} ({e['condition']}, " + f"{e['split']} split, {e['n_fov']} FOVs, " + f"shape {_format_shape(e['shape_min'], e['shape_max'])})" + ), + "contentUrl": f"{s3_base}/{e['split']}/{e['file']}", + "sameAs": [f"{https_base}/{e['split']}/{e['file']}"], + "encodingFormat": "application/vnd.ome.zarr+zip", + "sha256": sha256, + "contentSize": str(e["size_bytes"]), + } + ) + + file_objects.append( + { + "@type": "cr:FileObject", + "@id": "dynacell-code-repo", + "name": "VisCy — DynaCell application code", + "description": ("Training, prediction, evaluation, and reporting pipelines. BSD-3-Clause license."), + "contentUrl": "https://github.com/mehta-lab/VisCy/tree/modular-viscy-staging/applications/dynacell", + "encodingFormat": "application/x-git", + "license": "https://opensource.org/licenses/BSD-3-Clause", + "sha256": "", + } + ) + + demo_key = f"{static.aws_prefix}/demo/dynacell_a549_demo.zip" + file_objects.append( + { + "@type": "cr:FileObject", + "@id": "dynacell-demo-sample", + "name": "DynaCell reviewer-accessible sample", + "description": ( + "Reviewer-accessible sample (<4 GB) with a reduced number of " + "FOVs and timepoints, intended for quick inspection without " + "downloading the full release." + ), + "contentUrl": f"s3://{static.aws_bucket}/{demo_key}", + "sameAs": [f"https://{static.aws_bucket}.s3.us-west-2.amazonaws.com/{demo_key}"], + "encodingFormat": "application/zip", + "sha256": "", + } + ) + + targets = sorted({e["target"] for e in entries}) + conditions = sorted({e["condition"] for e in entries}) + total_fov = sum(e["n_fov"] for e in entries) + total_size_gb = sum(e["size_bytes"] for e in entries) / 1e9 + ref_voxel = entries[0]["voxel_size"] + voxel_clause = ( + f" Voxel spacing (Z,Y,X) µm/px: {ref_voxel[2]}, {ref_voxel[3]}, {ref_voxel[4]}." + if ref_voxel is not None + else "" + ) + + organelles = [_TARGET_META.get(t, (t.upper(), t, t))[1] for t in targets] + channel_counts = sorted({e["shape_min"][1] for e in entries}) + channel_clause = ( + f" {channel_counts[0]} channels per FOV (label-free Phase3D + brightfield + fluorescence target)." + if len(channel_counts) == 1 + else f" {channel_counts[0]}–{channel_counts[-1]} channels per FOV " + "(label-free Phase3D + brightfield + auxiliary / target fluorescence)." + ) + + return { + "@context": CROISSANT_CONTEXT, + "@type": "sc:Dataset", + "conformsTo": "http://mlcommons.org/croissant/1.1", + "name": static.name, + "description": ( + f"{static.name} — paired label-free + fluorescence 3D imaging " + "for virtual staining and cell profiling. This release " + f"contains {len(entries)} OZX stores across {len(targets)} " + f"organelle targets ({', '.join(targets)}) and " + f"{len(conditions)} condition(s) ({', '.join(conditions)}), " + f"totalling {total_fov} FOVs ({total_size_gb:.0f} GB)." + channel_clause + voxel_clause + ), + "version": "1.1.0", + "license": static.license_url, + "citeAs": static.cite_as, + "url": "https://registry.opendata.aws/dynacell/", + "isLiveDataset": False, + "datePublished": "2026", + "inLanguage": "en", + # Only modality terms are shared across releases. Cell line and platform + # come from StaticFields: this builder runs per dataset_prefix, so a + # hardcoded "A549" would keyword the Allen WTC-11 subset as A549. + "keywords": [ + "virtual staining", + "live-cell imaging", + "label-free microscopy", + "fluorescence microscopy", + "3D time-lapse", + "benchmark", + "OME-Zarr", + *static.keywords, + *sorted(organelles), + *sorted(conditions), + ], + "creator": list(static.creators), + "publisher": { + "@type": "sc:Organization", + "name": static.publisher_name, + "url": static.publisher_url, + }, + "funder": { + "@type": "sc:Organization", + "name": "Biohub San Francisco", + }, + "distribution": file_objects, + "rai:dataCollection": static.rai_data_collection, + "rai:dataBiases": static.rai_data_biases, + "rai:annotationsPerItem": static.rai_annotations_per_item, + "rai:personalSensitiveInformation": static.rai_personal_sensitive_information, + "rai:dataLimitations": static.rai_data_limitations, + "rai:dataUseCases": static.rai_data_use_cases, + "rai:dataSocialImpact": static.rai_data_social_impact, + "prov:wasDerivedFrom": list(static.prov_was_derived_from), + "prov:wasGeneratedBy": list(static.prov_was_generated_by), + "rai:hasSyntheticData": static.rai_has_synthetic_data, + } + + +def merge_croissant_docs( + docs: list[dict[str, Any]], + *, + name: str = "DynaCell", +) -> dict[str, Any]: + """Merge per-dataset Croissant docs into one release-wide document. + + Each input is a complete single-dataset Croissant produced by + :func:`build_croissant_from_release`. The release ships a single + ``metadata/croissant.json`` covering subsets with **different licenses** + (A549 = CC-BY-4.0, iPSC = Allen Institute Terms of Use), so the merge: + + - unions ``distribution``, tagging every per-store ``cr:FileObject`` + (``@id`` contains ``"/"``) with a per-file ``license`` equal to its + source doc's top-level ``license``; + - deduplicates shared FileObjects (code repo, demo sample) by ``@id``; + - sets a release-wide ``name`` and ``license`` (the list of distinct + per-subset licenses), keeps the superset ``citeAs``, and unions + ``keywords``; + - concatenates per-subset RAI prose and ``prov:*`` provenance so no + subset's statement is dropped. + + Parameters + ---------- + docs + Per-dataset Croissant documents, in the order they should appear. + name + Release-wide dataset name for the merged document. + + Returns + ------- + dict + A single Croissant 1.1 document covering all input datasets. + """ + import copy + + if not docs: + raise ValueError("merge_croissant_docs requires at least one document") + + merged = copy.deepcopy(docs[0]) + + # distribution: union, per-file license on stores, dedup shared assets. + seen: set[str] = set() + distribution: list[dict[str, Any]] = [] + for doc in docs: + doc_license = doc["license"] + for file_object in doc["distribution"]: + file_id = file_object["@id"] + if file_id in seen: + continue + seen.add(file_id) + file_object = copy.deepcopy(file_object) + # Per-store OZX FileObjects use "//" ids and + # inherit their dataset's license; shared assets (code repo, demo) + # have no "/" and keep any license they already declare. + if "/" in file_id and "license" not in file_object: + file_object["license"] = doc_license + distribution.append(file_object) + merged["distribution"] = distribution + + merged["name"] = name + licenses = list(dict.fromkeys(doc["license"] for doc in docs)) + merged["license"] = licenses if len(licenses) > 1 else licenses[0] + # The most complete citeAs already unions the per-subset references. + merged["citeAs"] = max((doc["citeAs"] for doc in docs), key=len) + keywords: list[str] = [] + for doc in docs: + for keyword in doc.get("keywords", []): + if keyword not in keywords: + keywords.append(keyword) + merged["keywords"] = keywords + + n_stores = sum(1 for fo in distribution if "/" in fo["@id"]) + subset_names = ", ".join(doc["name"] for doc in docs) + merged["description"] = ( + f"{name} — paired label-free + fluorescence 3D imaging for virtual " + "staining and cell profiling. Release-wide document covering " + f"{len(docs)} dataset subsets ({subset_names}) across {n_stores} OZX " + "stores. Subsets may carry different licenses; see each store's " + "license field and the per-subset RAI statements below." + ) + + # RAI prose + provenance: concatenate per subset so nothing is dropped. + for field in ( + "rai:dataCollection", + "rai:dataBiases", + "rai:annotationsPerItem", + "rai:personalSensitiveInformation", + "rai:dataLimitations", + "rai:dataUseCases", + "rai:dataSocialImpact", + ): + present = [doc for doc in docs if doc.get(field)] + distinct = list(dict.fromkeys(doc[field] for doc in present)) + if len(distinct) <= 1: + merged[field] = distinct[0] if distinct else merged.get(field, "") + else: + merged[field] = "\n\n".join(f"{doc['name']}: {doc[field]}" for doc in present) + merged["rai:hasSyntheticData"] = any(doc.get("rai:hasSyntheticData", False) for doc in docs) + for field in ("prov:wasDerivedFrom", "prov:wasGeneratedBy"): + combined: list[Any] = [] + for doc in docs: + for item in doc.get(field, []): + if item not in combined: + combined.append(item) + merged[field] = combined + + return merged diff --git a/applications/dynacell/src/dynacell/croissant/cli.py b/applications/dynacell/src/dynacell/croissant/cli.py new file mode 100644 index 000000000..4a5ea623d --- /dev/null +++ b/applications/dynacell/src/dynacell/croissant/cli.py @@ -0,0 +1,589 @@ +"""``croissant`` subcommand entry points. + +Wired into the ``dynacell`` top-level dispatcher (``_ARGPARSE_COMMANDS`` +in ``dynacell/__main__.py``). The retired ``dynacell-paper`` console +script this originally targeted was removed by the Phase 13 migration. +The dispatcher strips its own subcommand token from ``sys.argv`` +before invoking ``main()``, so by the time argparse runs here +``sys.argv[1:]`` holds the croissant-side flags. +""" + +import argparse +import json +import sys +from pathlib import Path + + +def main() -> None: + """Route ``dynacell croissant {from-release|validate}`` to handlers.""" + parser = argparse.ArgumentParser(prog="dynacell croissant") + sub = parser.add_subparsers(dest="action", required=True) + + rel = sub.add_parser( + "from-release", + help="Generate Croissant by scanning OZX stores in a release tree.", + ) + rel.add_argument( + "--release-root", + type=Path, + required=True, + dest="release_root", + help="Root of the release tree (expects data//{train,test}/*.ozx).", + ) + rel.add_argument( + "--dataset-prefix", + default="biohub-a549", + dest="dataset_prefix", + help="Subdirectory under data/ to scan (default: biohub-a549).", + ) + rel.add_argument( + "--output", + type=Path, + required=True, + help="Output path for the generated JSON file.", + ) + rel.add_argument( + "--compute-sha256", + action="store_true", + dest="compute_sha256", + help="Compute SHA-256 for each OZX file (slow for large archives).", + ) + rel.add_argument( + "--no-validate", + action="store_true", + help="Skip mlcroissant validation after generation.", + ) + + mrg = sub.add_parser( + "merge-release", + help="Generate one release-wide Croissant covering all dataset subsets.", + ) + mrg.add_argument( + "--release-root", + type=Path, + required=True, + dest="release_root", + help="Root of the release tree (expects data//{train,test}/*.ozx).", + ) + mrg.add_argument( + "--dataset-prefix", + action="append", + dest="dataset_prefixes", + help="Subdirectory under data/ to scan; repeatable (default: biohub-a549 then aics-hipsc).", + ) + mrg.add_argument( + "--output", + type=Path, + required=True, + help="Output path for the generated JSON file.", + ) + mrg.add_argument( + "--compute-sha256", + action="store_true", + dest="compute_sha256", + help="Compute SHA-256 for each OZX file (slow for large archives).", + ) + mrg.add_argument( + "--no-validate", + action="store_true", + help="Skip mlcroissant validation after generation.", + ) + + val = sub.add_parser("validate", help="Validate a Croissant JSON-LD doc.") + val.add_argument("path", type=Path, help="Path to the JSON file.") + + args = parser.parse_args(sys.argv[1:]) + + if args.action == "from-release": + _do_from_release(args) + elif args.action == "merge-release": + _do_merge_release(args) + elif args.action == "validate": + _do_validate(args) + + +def _do_from_release(args: argparse.Namespace) -> None: + """Build Croissant by scanning OZX stores in a release tree.""" + from dynacell.croissant.builder import build_croissant_from_release + + static = _static_fields_for(args.dataset_prefix) + jsonld = build_croissant_from_release( + release_root=args.release_root, + static=static, + dataset_prefix=args.dataset_prefix, + compute_sha256=args.compute_sha256, + ) + + if not args.no_validate: + from dynacell.croissant.validate import validate_croissant + + validate_croissant(jsonld) + + args.output.parent.mkdir(parents=True, exist_ok=True) + args.output.write_text(json.dumps(jsonld, sort_keys=True, indent=2) + "\n") + print(f"Wrote {args.output}") + + +def _do_merge_release(args: argparse.Namespace) -> None: + """Merge per-dataset Croissant docs into one release-wide document.""" + from dynacell.croissant.builder import ( + build_croissant_from_release, + merge_croissant_docs, + ) + + prefixes = args.dataset_prefixes or ["biohub-a549", "aics-hipsc"] + docs = [ + build_croissant_from_release( + release_root=args.release_root, + static=_static_fields_for(prefix), + dataset_prefix=prefix, + compute_sha256=args.compute_sha256, + ) + for prefix in prefixes + ] + jsonld = merge_croissant_docs(docs) + + if not args.no_validate: + from dynacell.croissant.validate import validate_croissant + + validate_croissant(jsonld) + + args.output.parent.mkdir(parents=True, exist_ok=True) + args.output.write_text(json.dumps(jsonld, sort_keys=True, indent=2) + "\n") + print(f"Wrote {args.output} ({len(prefixes)} datasets: {', '.join(prefixes)})") + + +def _do_validate(args: argparse.Namespace) -> None: + """Run mlcroissant validation against a path; raises on issues.""" + from dynacell.croissant.validate import validate_croissant + + validate_croissant(args.path) + print(f"Validated {args.path}") + + +_CONTACT_EMAIL = "shalin.mehta@czbiohub.org" + +# Creator entries shared by every DynaCell release. The per-dataset factories +# add the institution that acquired that subset's data. +_BIOHUB_ORG: dict[str, object] = { + "@type": "sc:Organization", + "name": "Biohub San Francisco", + "url": "https://www.czbiohub.org", +} +_CORRESPONDING_AUTHOR: dict[str, object] = { + "@type": "sc:Person", + "name": "Shalin B. Mehta", + "email": _CONTACT_EMAIL, + "affiliation": {"@type": "sc:Organization", "name": "Biohub San Francisco"}, +} + +_DYNACELL_BIBTEX = ( + "@inproceedings{dynacell2026, " + "title={{DynaCell}: an Evaluation Framework for Dynamic 3D " + "Virtual Staining of Live Cells}, " + "author={Kalinin, Alexandr A. and Zheng, Dihan and " + "Theodoro, Taylla Milena and Ivanov, Ivan and " + "Hirata-Miyasaki, Eduardo and Lee, See-Chi and Liu, Aofei and " + "Varra, Sricharan Reddy and Chandler, Talon and Pradeep, Soorya " + "and Liu, Chad and Leonetti, Manuel D. and Arias, Carolina and " + "Huang, Bo and Mehta, Shalin B.}, " + "booktitle={Advances in Neural Information Processing Systems " + "(NeurIPS) Evaluations and Datasets Track}, year={2026}}" +) + +_VIANA_BIBTEX = ( + "@article{viana2023ipsc, " + "title={Integrated intracellular organization and its variations in " + "human iPS cells}, " + "author={Viana, Matheus P. and Chen, Jianxu and Schroeder, " + "Theo A. and others}, " + "journal={Nature}, volume={613}, pages={345--354}, year={2023}, " + "doi={10.1038/s41586-022-05553-z}}" +) + +_AICS2018_BIBTEX = ( + "@misc{aics2018hipsc, " + "title={{hiPSC Single-cell Image Dataset}}, " + "author={{Allen Institute for Cell Science}}, " + "year={2018}, " + "howpublished={\\url{https://www.allencell.org/3d-cell-viewer.html}}, " + "note={Used under the Allen Institute Terms of Use, " + "\\url{https://www.allencell.org/terms-of-use.html}}}" +) + + +def _static_fields_for(dataset_prefix: str): + """Dispatch to the dataset-specific :class:`StaticFields` factory.""" + if dataset_prefix == "biohub-a549": + return _a549_static_fields() + if dataset_prefix == "aics-hipsc": + return _aics_hipsc_static_fields() + raise ValueError( + f"No static fields defined for dataset_prefix={dataset_prefix!r}; add a factory in dynacell/croissant/cli.py" + ) + + +def _a549_static_fields(): + """``StaticFields`` for the biohub-a549 release dataset. + + Authoring constants (license CC-BY-4.0, citation, RAI prose) reflect + the in-house Biohub Mantis acquisition. Bucket / prefix and the + DynaCell BibTeX remain placeholders pending PLAN.md O-1/O-2. + """ + from dynacell.croissant.static import StaticFields + + return StaticFields( + name="DynaCell — A549 (Mantis)", + license_url="https://creativecommons.org/licenses/by/4.0/", + cite_as=_DYNACELL_BIBTEX, + keywords=("A549", "Mantis"), + creators=( + _BIOHUB_ORG, + { + "@type": "sc:Organization", + "name": "University of California San Francisco — Huang Lab", + "url": "https://huanglab.ucsf.edu", + }, + _CORRESPONDING_AUTHOR, + ), + publisher_name="AWS Open Data", + publisher_url="https://registry.opendata.aws", + contact_email=_CONTACT_EMAIL, + aws_bucket="dynacell", + aws_prefix="v1", + rai_data_collection=( + "The DynaCell A549 dataset was acquired on the Mantis correlative " + "light-sheet fluorescence and label-free microscope at Biohub " + "San Francisco. A549 human lung adenocarcinoma cells (ATCC CCL-185) " + "were cultured and imaged under three conditions: mock-infected, " + "Zika virus-infected, and Dengue virus-infected (both BSL-2). " + "Each field of view is a paired 3D time-lapse acquisition combining " + "label-free transmitted-light channels (multi-angle phase) and a " + "single fluorescence target marker per store (H2B / nucleus, CAAX / " + "membrane, SEC61B / endoplasmic reticulum, or TOMM20 / mitochondria). " + "Plates were imaged at native cadences of 10, 30, or 120 minutes " + "within an evaluation window of approximately 5–21 hours post-" + "infection (hpi) and subsampled to a shared 2-hour grid aligned " + "to integer hpi (~10 frames per FOV) prior to splitting." + ), + rai_data_biases=( + "The dataset covers a single human cell line (A549) acquired on a " + "single microscope platform (Mantis correlative light-sheet " + "fluorescence and label-free). Models trained on this data may not " + "generalize to other cell types, tissue types, organisms, or " + "microscope platforms without additional validation. The " + "perturbation panel covers only Zika and Dengue viruses." + ), + rai_annotations_per_item=("Each FOV provides paired label-free and fluorescence volumes as ground truth."), + rai_personal_sensitive_information=( + "None. All data derive from an established immortalized cell line " + "(A549, ATCC CCL-185). No human participants or identifiable " + "biological material are involved." + ), + rai_data_limitations=( + "A549 is a cancer cell line; its organelle morphology may differ " + "from non-transformed cells. Each acquired field of view carries a " + "single fluorescence target marker." + ), + rai_data_use_cases=( + "The dataset is intended for two tasks: (1) virtual staining — " + "predicting fluorescent organelle channels from label-free " + "transmitted-light volumes; (2) representation learning of " + "organelle morphology and dynamics in 3D live cells. Validated use " + "cases (paired test set, see accompanying paper): zero-shot and " + "fine-tuned virtual staining of nuclear (H2B), membrane (CAAX), " + "endoplasmic reticulum (SEC61B), and mitochondrial (TOMM20) " + "targets in A549 cells under mock, ZIKV, and DENV conditions, " + "evaluated with PCC, SSIM, and FID. Not validated for: clinical " + "or diagnostic decision support; automated drug discovery without " + "independent wet-lab validation; cross-cell-line, cross-organism, " + "or cross-microscope generalization without retraining or " + "recalibration; segmentation of structures other than the four " + "targets above." + ), + rai_data_social_impact=( + "Positive impact: virtual staining reduces phototoxicity and " + "photobleaching in long-term live-cell imaging by lowering the " + "required fluorescence dose, enabling experiments that are " + "currently impossible on light-sensitive samples. Public release " + "of paired label-free / fluorescence volumes lowers the barrier " + "to entry for image-translation research in microscopy. Risks: " + "misuse for clinical diagnosis or pre-clinical decisions without " + "independent validation on the relevant cell type and imaging " + "platform; over-interpretation of virtual-stain outputs as " + "faithful proxies for biological ground truth in quantitative " + "measurements where small intensity errors matter (e.g., kinetic " + "flux, single-molecule counting). Mitigations: the dataset is " + "released as an evaluation benchmark with frozen test splits and " + "held-out perturbations; full data limitations and bias " + "statements are published alongside the data; benchmark code, " + "splits, and metric implementations are open-source so claims " + "can be reproduced and audited." + ), + rai_has_synthetic_data=False, + prov_was_derived_from=[ + { + "@id": "https://www.atcc.org/products/ccl-185", + "prov:label": "A549 cell line (ATCC CCL-185)", + "description": ( + "Source cell line for the biohub-a549 release; " + "imaging data was acquired in-house at Biohub San " + "Francisco on the Mantis correlative light-sheet " + "fluorescence and label-free microscope. No external " + "image dataset was used as input." + ), + "prov:wasAttributedTo": { + "@id": "https://www.atcc.org", + "prov:label": "American Type Culture Collection", + }, + }, + ], + prov_was_generated_by=[ + { + "@type": "prov:Activity", + "prov:type": {"@id": "https://www.wikidata.org/wiki/Q4929239"}, # Data Collection + "prov:label": "Mantis acquisition", + "description": ( + "3D time-lapse multi-channel acquisition on the " + "Mantis correlative light-sheet fluorescence and " + "label-free microscope at Biohub San Francisco. A549 " + "human lung adenocarcinoma cells were imaged under " + "three conditions (mock, ZIKV, DENV) with a single " + "fluorescence target marker per store (H2B / nucleus, " + "CAAX / membrane, SEC61B / endoplasmic reticulum, or " + "TOMM20 / mitochondria)." + ), + "prov:wasAttributedTo": [ + { + "@type": "prov:Agent", + "@id": "biohub_research_team", + "prov:label": "Biohub San Francisco research team", + }, + ], + }, + { + "@type": "prov:Activity", + "prov:label": "DynaCell preprocessing", + "description": ( + "Phase reconstruction from multi-angle transmitted-" + "light volumes via the open-source waveorder " + "pipeline; co-registration of label-free and " + "fluorescence channels; per-FOV deskewing and stage-" + "position metadata correction; channel-wise " + "normalization statistics computed and stored as zarr " + "attributes. Train/test partitions are FOV-level and " + "frozen at v1.0." + ), + "prov:wasAttributedTo": [ + { + "@type": "prov:Agent", + "@id": "dynacell_authors", + "prov:label": "Kalinin et al., Biohub SF", + }, + { + "@type": "prov:SoftwareAgent", + "@id": "https://github.com/mehta-lab/waveorder", + "prov:label": "waveorder", + "description": ("Open-source phase reconstruction pipeline."), + }, + ], + }, + ], + ) + + +def _aics_hipsc_static_fields(): + """``StaticFields`` for the aics-hipsc release dataset. + + Reprocessed subset of the Allen Institute hiPSC Single-cell Image + Dataset (Viana et al., Nature 2023). License is the Allen Institute + Terms of Use (noncommercial research); citation includes both the + DynaCell paper and Viana et al. per Allen citation policy. + """ + from dynacell.croissant.static import StaticFields + + return StaticFields( + name="DynaCell — iPSC (WTC-11)", + license_url="https://www.allencell.org/terms-of-use.html", + cite_as=_DYNACELL_BIBTEX + "\n\n" + _VIANA_BIBTEX + "\n\n" + _AICS2018_BIBTEX, + keywords=("WTC-11", "iPSC"), + # The Allen Institute acquired this data; DynaCell reprocessed it. Allen + # must appear in `creator` -- that is the field aggregators read -- not + # only in prov:wasDerivedFrom. UCSF Huang Lab is deliberately absent: it + # contributed to the A549 acquisition, not this subset. + creators=( + _BIOHUB_ORG, + { + "@type": "sc:Organization", + "name": "Allen Institute for Cell Science", + "url": "https://www.allencell.org", + }, + _CORRESPONDING_AUTHOR, + ), + publisher_name="AWS Open Data", + publisher_url="https://registry.opendata.aws", + contact_email=_CONTACT_EMAIL, + aws_bucket="dynacell", + aws_prefix="v1", + rai_data_collection=( + "The DynaCell iPSC subset is reprocessed from the Allen " + "Institute hiPSC Single-cell Image Dataset (Viana et al., " + "Nature 2023). The Allen Institute for Cell Science acquired " + "paired brightfield and 3D confocal fluorescence volumes of " + "WTC-11 human induced pluripotent stem cells (single donor, " + "gene-edited line) on a spinning-disk confocal microscope, " + "with endogenous fluorescent tags marking organelle-specific " + "proteins. DynaCell selects four targets — H2B / nucleus, " + "CAAX / cell membrane, SEC61B / endoplasmic reticulum, and " + "TOMM20 / mitochondria — and reconstructs the corresponding " + "3D phase channel from the brightfield input via the open-" + "source waveorder pipeline. 500 FOVs per organelle in the " + "training split, 100 in the held-out evaluation split." + ), + rai_data_biases=( + "The dataset covers a single human induced pluripotent stem " + "cell line (WTC-11) acquired on a single platform (Allen " + "Institute spinning-disk confocal). Models trained on this " + "data may not generalize to other iPSC lines, differentiated " + "cell types, primary cells, organisms, or microscope " + "platforms without additional validation. The endogenous-" + "tagging strategy targets specific protein loci within each " + "organelle and may not capture morphological variation " + "visible with alternative markers." + ), + rai_annotations_per_item=( + "Each FOV provides paired label-free (brightfield + " + "reconstructed Phase3D) and confocal fluorescence volumes as " + "ground truth." + ), + rai_personal_sensitive_information=( + "None. All data derive from the WTC-11 hiPSC line, originally " + "established at the Conklin Laboratory (Gladstone Institutes / " + "UCSF) and distributed via the Coriell Institute (catalog " + "GM25256); the Allen Institute used genome editing to insert " + "endogenous fluorescent tags. The original donor consented to " + "research use of the derived line; the released image data " + "contain no genomic sequence or other donor-identifying " + "information." + ), + rai_data_limitations=( + "Single iPSC line (WTC-11); organelle morphology may differ " + "from differentiated cell types or other iPSC lines. The " + "DynaCell subset covers 4 of the broader Allen Institute " + "organelle target set; users wanting additional markers " + "should consult the original Allen dataset (linked in " + "prov:wasDerivedFrom). The Phase3D channel is computationally " + "reconstructed from brightfield via the open-source waveorder " + "pipeline; reconstruction quality is bounded by that pipeline." + ), + rai_data_use_cases=( + "The dataset is intended for two tasks: (1) virtual staining " + "— predicting fluorescent organelle channels (nucleus, " + "membrane, ER, mitochondria) from label-free transmitted-" + "light volumes; (2) representation learning of organelle " + "morphology in 3D iPSCs. Validated use cases (held-out 100-" + "FOV evaluation split, see accompanying paper): zero-shot " + "and fine-tuned virtual staining of the four targets above, " + "evaluated with PCC, SSIM, and FID; representation learning " + "evaluated against organelle classification benchmarks. Not " + "validated for: clinical or diagnostic decision support; " + "cross-cell-line, cross-organism, or cross-microscope " + "generalization without retraining." + ), + rai_data_social_impact=( + "Positive impact: virtual staining reduces phototoxicity and " + "photobleaching in long-term live-cell imaging by lowering " + "the required fluorescence dose. Coupling DynaCell's iPSC " + "training corpus with the A549 dynamic test set enables " + "principled evaluation of how well models trained on a " + "static, paired iPSC dataset generalize to dynamic, " + "perturbed cancer-cell imaging — a real-world transfer " + "scenario for stem-cell research. Risks: misuse for clinical " + "diagnosis or therapeutic-grade decisions about iPSC-derived " + "products without independent validation; over-interpretation " + "of virtual-stain outputs as faithful proxies for biological " + "ground truth in quantitative measurements where small " + "intensity errors matter. Mitigations: the dataset is " + "released as an evaluation benchmark with frozen test " + "splits; full data limitations and bias statements are " + "published alongside the data; benchmark code, splits, and " + "metric implementations are open-source so claims can be " + "reproduced and audited." + ), + rai_has_synthetic_data=False, + prov_was_derived_from=[ + { + "@id": "https://www.allencell.org/data/hipsc-single-cell.html", + "prov:label": "Allen Institute hiPSC Single-cell Image Dataset", + "description": ( + "Original paired imaging dataset of WTC-11 hiPSC " + "lines acquired on the Allen Institute spinning-disk " + "confocal microscope; the DynaCell iPSC subset " + "reprocesses 4 of the broader Allen target set with " + "phase reconstruction added via the open-source " + "waveorder pipeline. Citation: Viana, M.P., Chen, " + "J., Schroeder, T.A. et al. Integrated intracellular " + "organization and its variations in human iPS cells. " + "Nature 613, 345-354 (2023). " + "https://doi.org/10.1038/s41586-022-05553-z" + ), + "sc:license": "https://www.allencell.org/terms-of-use.html", + "prov:wasAttributedTo": { + "@id": "https://www.allencell.org", + "prov:label": "Allen Institute for Cell Science", + }, + }, + ], + prov_was_generated_by=[ + { + "@type": "prov:Activity", + "prov:type": {"@id": "https://www.wikidata.org/wiki/Q4929239"}, # Data Collection + "prov:label": "Allen Institute hiPSC acquisition", + "description": ( + "3D paired brightfield + confocal fluorescence " + "acquisition of WTC-11 hiPSC lines on the Allen " + "Institute spinning-disk confocal microscope. " + "Endogenous fluorescent tags marked organelle-" + "specific proteins." + ), + "prov:wasAttributedTo": [ + { + "@type": "prov:Agent", + "@id": "allen_institute_for_cell_science", + "prov:label": "Allen Institute for Cell Science", + "description": ( + "See Viana et al., Nature 2023 " + "(https://doi.org/10.1038/s41586-022-05553-z) " + "for the canonical reference." + ), + }, + ], + }, + { + "@type": "prov:Activity", + "prov:label": "DynaCell reprocessing", + "description": ( + "Selection of 4 target organelles (nucleus, " + "membrane, ER, mitochondria) from the broader Allen " + "target set; phase reconstruction from brightfield " + "via the open-source waveorder pipeline; per-FOV " + "channel-wise normalization statistics computed and " + "stored as zarr attributes; train/test split frozen " + "at FOV level (500 train, 100 test per organelle)." + ), + "prov:wasAttributedTo": [ + { + "@type": "prov:Agent", + "@id": "dynacell_authors", + "prov:label": "Kalinin et al., Biohub SF", + }, + { + "@type": "prov:SoftwareAgent", + "@id": "https://github.com/mehta-lab/waveorder", + "prov:label": "waveorder", + "description": ("Open-source phase reconstruction pipeline."), + }, + ], + }, + ], + ) diff --git a/applications/dynacell/src/dynacell/croissant/static.py b/applications/dynacell/src/dynacell/croissant/static.py new file mode 100644 index 000000000..74963a640 --- /dev/null +++ b/applications/dynacell/src/dynacell/croissant/static.py @@ -0,0 +1,107 @@ +"""Static fields for Croissant generation. + +Holds the prose + identifiers that cannot be derived from manifests: +license, citation, contact, RAI narrative blocks. Every field is +required at instantiation time so a half-filled run fails fast — there +is no silent placeholder fallback. +""" + +from dataclasses import dataclass + + +@dataclass(frozen=True) +class StaticFields: + """Immutable bag of authoring-time constants for a Croissant doc. + + Parameters + ---------- + name + Top-level ``name`` field for the Croissant doc (e.g. + ``"DynaCell — A549 (Mantis)"``). Must distinguish this dataset + from any sibling release docs in the same publication. + license_url + Canonical license URL (e.g. ``https://creativecommons.org/licenses/by/4.0/``). + cite_as + BibTeX entry for the dataset's primary citation. + keywords + Dataset-specific ``keywords`` entries, appended to the shared modality + terms every DynaCell release carries. Cell line and platform belong + here — they differ per release and must not be hardcoded in the builder. + creators + Top-level ``creator`` block, verbatim JSON-LD entries. This is the field + aggregators read for attribution, so the list must name the institutions + that produced *this* subset's data, not the release as a whole; upstream + provenance additionally goes in ``prov_was_derived_from``. + publisher_name, publisher_url + Top-level ``publisher`` block. + contact_email + Contact for dataset issues. + aws_bucket + S3 bucket name (without ``s3://``) hosting the OZX artifacts. + aws_prefix + Key prefix inside the bucket (e.g. ``"dynacell/v1"``). + rai_data_collection + Prose for ``rai:dataCollection`` — how the data was acquired. + rai_data_biases + Prose for ``rai:dataBiases`` — known sampling/scope biases. + rai_annotations_per_item + Prose for ``rai:annotationsPerItem`` — what's annotated per FOV. + rai_personal_sensitive_information + Prose for ``rai:personalSensitiveInformation``. + rai_data_limitations + Prose for ``rai:dataLimitations`` — known limitations / caveats. + Used in place of the non-existent ``rai:ethicalReview``. + rai_data_use_cases + Prose for ``rai:dataUseCases`` — validated tasks and out-of-scope use. + rai_data_social_impact + Prose for ``rai:dataSocialImpact`` — positive impact, risks, mitigations. + prov_was_derived_from + Structured ``prov:wasDerivedFrom`` entries — list of upstream + sources this release is derived from (PROV-O). Each entry is a + dict with at minimum ``@id``, ``prov:label``, ``description``, + and optionally ``sc:license`` and ``prov:wasAttributedTo``. + See NeurIPS RAI guidelines for the exact shape. + prov_was_generated_by + Structured ``prov:wasGeneratedBy`` entries — list of + ``prov:Activity`` dicts describing collection / preprocessing / + annotation steps, each with ``@type``, ``prov:label``, + ``description``, and ``prov:wasAttributedTo`` listing the + agents / software involved. + """ + + name: str + license_url: str + cite_as: str + keywords: tuple[str, ...] + creators: tuple[dict[str, object], ...] + publisher_name: str + publisher_url: str + contact_email: str + aws_bucket: str + aws_prefix: str + rai_data_collection: str + rai_data_biases: str + rai_annotations_per_item: str + rai_personal_sensitive_information: str + rai_data_limitations: str + rai_data_use_cases: str + rai_data_social_impact: str + rai_has_synthetic_data: bool + prov_was_derived_from: list[dict[str, object]] + prov_was_generated_by: list[dict[str, object]] + + def __post_init__(self) -> None: + """Reject any None / empty-string / empty-list field at construction time. + + Boolean fields (``rai_has_synthetic_data``) are exempt: ``False`` + is a meaningful value distinct from "unset". + """ + for field_name in self.__dataclass_fields__: + value = getattr(self, field_name) + if isinstance(value, bool): + continue + if value is None or value == "" or value == []: + raise ValueError( + f"StaticFields.{field_name} is required and must be non-empty; " + "fill in real values before generating Croissant" + ) diff --git a/applications/dynacell/src/dynacell/croissant/validate.py b/applications/dynacell/src/dynacell/croissant/validate.py new file mode 100644 index 000000000..36b711971 --- /dev/null +++ b/applications/dynacell/src/dynacell/croissant/validate.py @@ -0,0 +1,44 @@ +"""Croissant JSON-LD validation. + +Wraps ``mlcroissant.Dataset(jsonld=...)`` so a malformed doc raises +loudly. Imports ``mlcroissant`` at module top — a missing dep produces +``ModuleNotFoundError`` that propagates with the standard "module not +installed" message; the package README documents +``uv sync --extra croissant`` as the install path. +""" + +import copy +from pathlib import Path +from typing import Any + +import mlcroissant as mlc + + +def validate_croissant(jsonld: dict[str, Any] | Path) -> None: + """Validate a Croissant JSON-LD doc; raise on any issue. + + Parameters + ---------- + jsonld + Either an in-memory dict or a ``Path`` (or path-like) to a + JSON file. Raw JSON strings are not supported — parse them + with :func:`json.loads` first and pass the resulting dict. + + Raises + ------ + Exception + Any error mlcroissant surfaces during validation. We do not + catch — callers see the raw mlcroissant error so the cause is + visible without a layer of translation. + + Notes + ----- + ``mlcroissant.Dataset`` mutates the input dict (adds ``@base`` to + the JSON-LD context). We deep-copy the input first so the caller's + dict survives validation unchanged — important for the + in-sync-with-committed-JSON tests. + """ + if isinstance(jsonld, dict): + mlc.Dataset(jsonld=copy.deepcopy(jsonld)) + else: + mlc.Dataset(jsonld=Path(jsonld)) diff --git a/applications/dynacell/src/dynacell/data/README.md b/applications/dynacell/src/dynacell/data/README.md new file mode 100644 index 000000000..492dd44bb --- /dev/null +++ b/applications/dynacell/src/dynacell/data/README.md @@ -0,0 +1,25 @@ +# dynacell.data + +Dataset schemas and the manifest-driven resolver that turn a lightweight `DatasetRef` (`{dataset, target}`) +into concrete zarr paths, channel names, and voxel spacing. This is the indirection that lets benchmark leaves +carry `benchmark.dataset_ref` instead of duplicating absolute HPC paths. + +## Contents + +- `manifests.py` — Pydantic schemas for a dataset manifest: `DatasetManifest`, `TargetConfig`, `StoreLocations`, + `SplitDefinition`, `VoxelSpacing`, `DatasetRef`, plus `load_manifest` / `load_splits` / `get_target`. +- `resolver.py` — `resolve_dataset_ref` + manifest-root discovery. Root precedence: `cli_roots` arg → + `DYNACELL_MANIFEST_ROOTS` env → `dynacell.manifest_roots` entry point (defaults to + [`_manifests/`](../_manifests/README.md)). Looks for `//manifest.yaml`, first hit wins. + Errors: `ManifestNotFoundError`, `NoManifestRootsError`, `TargetNotFoundError`. +- `collections.py` — `BenchmarkCollection` / `CollectionExperiment` / `ChannelEntry` / `Provenance` schemas + + `load_collection` for describing multi-experiment collections. +- `specs.py` — `BenchmarkSpec` + `load_benchmark_spec` for reproducible run specs. +- `_yaml.py` — shared YAML loading helpers. + +The compose-time splice lives in [`../_compose_hook.py`](../README.md) (train/predict leaves) and +`evaluation/_ref_hook.py` (eval leaves), both of which call this resolver. + +## Navigation + +- Up: [dynacell](../README.md) diff --git a/applications/dynacell/src/dynacell/data/__init__.py b/applications/dynacell/src/dynacell/data/__init__.py index 9843e505a..624a9d886 100644 --- a/applications/dynacell/src/dynacell/data/__init__.py +++ b/applications/dynacell/src/dynacell/data/__init__.py @@ -18,6 +18,11 @@ load_manifest, load_splits, ) +from dynacell.data.registry import ( + get_manifest, + get_splits, + list_datasets, +) from dynacell.data.resolver import ( ManifestNotFoundError, NoManifestRootsError, @@ -47,7 +52,10 @@ "VoxelSpacing", "dataset_ref_from_dict", "discover_manifest_roots", + "get_manifest", + "get_splits", "get_target", + "list_datasets", "load_benchmark_spec", "load_collection", "load_manifest", diff --git a/applications/dynacell/src/dynacell/data/manifests.py b/applications/dynacell/src/dynacell/data/manifests.py index 5189d88ee..c63c4cffd 100644 --- a/applications/dynacell/src/dynacell/data/manifests.py +++ b/applications/dynacell/src/dynacell/data/manifests.py @@ -9,7 +9,7 @@ from functools import lru_cache from pathlib import Path -from pydantic import BaseModel, field_validator, model_validator +from pydantic import BaseModel, ConfigDict, field_validator, model_validator from dynacell.data._yaml import load_yaml @@ -21,10 +21,23 @@ class DatasetRef(BaseModel): The composition-time resolver reads this reference and splices ``data_path``, ``source_channel``, and ``target_channel`` into the composed Lightning config. + + ``source_channel`` overrides the manifest's declared ``channels.source`` + for input-channel ablations (e.g. feeding the raw ``Brightfield`` stack + instead of the ``Phase3D`` volume reconstructed from it) without minting a + duplicate dataset. Omit it to use the manifest default. + + Extra keys are **forbidden**: Pydantic's default would silently drop a + misspelled ``source_channel``, and the resulting run would train on the + manifest's default channel while every config, log and W&B name claimed + otherwise — an ablation that is a silent no-op is worse than one that fails. """ + model_config = ConfigDict(extra="forbid") + dataset: str target: str + source_channel: str | None = None class VoxelSpacing(BaseModel): @@ -40,9 +53,16 @@ def as_list(self) -> list[float]: class StoreLocations(BaseModel): - """Zarr store paths for a single organelle target.""" + """Zarr store paths for a single organelle target. + + ``train`` is optional: evaluation-only datasets (e.g. the ``hek-mantis-*`` + third-cell-type probe) ship a test store and no training data. Callers that + need a train store must check for ``None`` — :func:`resolve_dataset_ref` + propagates it as ``ResolvedDataset.data_path_train`` and the composition hook + raises for any non-predict Lightning mode. + """ - train: Path + train: Path | None = None test: Path cell_segmentation: Path | None = None gt_cache_dir: Path | None = None @@ -94,6 +114,42 @@ def source_channel(self) -> str: return source[0] raise ValueError(f"Manifest source channel must be a string or single-element list, got {source!r}.") + def resolve_source_channel(self, name: str | None) -> str: + """Return the model-input channel, validating an explicit override. + + Parameters + ---------- + name : str or None + Explicit channel from :attr:`DatasetRef.source_channel`. ``None`` + selects the manifest's declared :attr:`source_channel`. + + Returns + ------- + str + Channel name present in this manifest. + + Raises + ------ + ValueError + If ``name`` is not one of the manifest's declared channels. A typo + would otherwise surface as an opaque failure deep inside iohub, or + worse, silently select the wrong volume. + """ + if name is None: + return self.source_channel + # ``auxiliary`` is optional in the schema (``channels: dict[str, str | + # list[str]]``), so read it defensively -- absence is legal, not an error. + auxiliary = self.channels.get("auxiliary", []) + declared = [auxiliary] if isinstance(auxiliary, str) else list(auxiliary) + source = self.channels["source"] + declared += [source] if isinstance(source, str) else list(source) + if name not in declared: + raise ValueError( + f"source_channel {name!r} is not declared in manifest {self.name!r}. " + f"Available channels: {sorted(declared)}." + ) + return name + class SplitDefinition(BaseModel): """Train/val/test FOV split for one organelle.""" diff --git a/applications/dynacell/src/dynacell/data/registry.py b/applications/dynacell/src/dynacell/data/registry.py new file mode 100644 index 000000000..c9f1813da --- /dev/null +++ b/applications/dynacell/src/dynacell/data/registry.py @@ -0,0 +1,128 @@ +"""Name-based dataset registry for the DynaCell benchmark. + +Resolves bare dataset names (e.g. ``"aics-hipsc"``, +``"a549-mantis-sec61b-mock"``) to validated manifest objects, backed by the +manifest-roots resolver (:mod:`dynacell.data.resolver`). This is the +canonical home for the name-lookup API that ``dynacell-paper`` previously +carried in ``dynacell_paper.data.registry``. + +Distinct from :mod:`dynacell.data.manifests`, whose loaders take explicit +file paths, and from :func:`dynacell.data.manifests.get_target`, which takes +an already-loaded manifest object. Name-based target access is +``get_manifest(name).targets[target]`` (no shadowing symbol). +""" + +from __future__ import annotations + +from pathlib import Path + +from dynacell.data.manifests import ( + DatasetManifest, + SplitDefinition, + load_manifest, + load_splits, +) +from dynacell.data.resolver import ( + ManifestNotFoundError, + _find_manifest, + discover_manifest_roots, +) + + +def list_datasets() -> list[str]: + """Return all registered dataset names across configured manifest roots. + + Enumerates immediate subdirectories that contain a ``manifest.yaml`` + under each root returned by :func:`discover_manifest_roots`, in + precedence order (CLI → env var → entry points). A name discovered in a + higher-precedence root shadows later duplicates, matching the + first-hit-wins policy of the resolver. + + Returns + ------- + list[str] + Registered dataset names, e.g. ``["a549-mantis-caax-denv", ...]``. + """ + names: list[str] = [] + seen: set[str] = set() + for root in discover_manifest_roots(): + if not root.is_dir(): + continue + for child in sorted(root.iterdir()): + if child.name in seen or child.name.startswith(("_", ".")): + continue + if (child / "manifest.yaml").is_file(): + seen.add(child.name) + names.append(child.name) + return names + + +def _manifest_path(name: str) -> Path: + """Locate a dataset's ``manifest.yaml``, raising ``KeyError`` if absent. + + Wraps the resolver's :func:`_find_manifest`, translating its + :class:`ManifestNotFoundError` into ``KeyError`` so callers get the same + "unknown dataset name" contract as dict-style lookup. + """ + try: + return _find_manifest(name, discover_manifest_roots()) + except ManifestNotFoundError: + raise KeyError(f"Unknown dataset {name!r}. Available: {list_datasets()}") from None + + +def get_manifest(name: str) -> DatasetManifest: + """Load and validate a dataset manifest by registered name. + + Parameters + ---------- + name : str + Registered dataset name, e.g. ``"aics-hipsc"``. + + Returns + ------- + DatasetManifest + Validated manifest object (name-based target access via + ``get_manifest(name).targets[target]``). + + Raises + ------ + KeyError + If the dataset name is not registered under any manifest root. + """ + return load_manifest(_manifest_path(name)) + + +def get_splits(name: str, target: str) -> SplitDefinition: + """Load the split definition for a dataset target by name. + + Resolves the target's ``splits`` path relative to the manifest + directory, mirroring the path convention of the bundled registry. + + Parameters + ---------- + name : str + Registered dataset name. + target : str + Key in the manifest's ``targets`` dict, e.g. ``"sec61b"``. + + Returns + ------- + SplitDefinition + Validated split definition. + + Raises + ------ + KeyError + If the dataset name is unregistered or the target is absent. + FileNotFoundError + If the target's split file does not exist on disk. + """ + manifest_path = _manifest_path(name) + manifest = load_manifest(manifest_path) + if target not in manifest.targets: + available = ", ".join(sorted(manifest.targets)) or "(none)" + raise KeyError(f"Target {target!r} not in {name!r}. Available: {available}") + split_path = manifest_path.parent / manifest.targets[target].splits + if not split_path.is_file(): + raise FileNotFoundError(f"Split file for {name!r}/{target!r} not found: {split_path}") + return load_splits(split_path) diff --git a/applications/dynacell/src/dynacell/data/resolver.py b/applications/dynacell/src/dynacell/data/resolver.py index 29a26ad7a..4003fd36f 100644 --- a/applications/dynacell/src/dynacell/data/resolver.py +++ b/applications/dynacell/src/dynacell/data/resolver.py @@ -48,7 +48,7 @@ class ResolvedDataset(BaseModel): """Flat view of the manifest fields a composed config needs.""" manifest_path: Path - data_path_train: Path + data_path_train: Path | None = None data_path_test: Path source_channel: str target_channel: str @@ -172,6 +172,8 @@ def resolve_dataset_ref( If the dataset slug is not found under any root. TargetNotFoundError If the target slug is not defined in the located manifest. + ValueError + If ``ref.source_channel`` names a channel the manifest does not declare. """ all_roots = discover_manifest_roots(roots) manifest_path = _find_manifest(ref.dataset, all_roots) @@ -188,7 +190,7 @@ def resolve_dataset_ref( manifest_path=manifest_path, data_path_train=target.stores.train, data_path_test=target.stores.test, - source_channel=manifest.source_channel, + source_channel=manifest.resolve_source_channel(ref.source_channel), target_channel=target.target_channel, spacing=manifest.spacing, cell_segmentation_path=target.stores.cell_segmentation, diff --git a/applications/dynacell/src/dynacell/distribution/__init__.py b/applications/dynacell/src/dynacell/distribution/__init__.py new file mode 100644 index 000000000..d6b1bd961 --- /dev/null +++ b/applications/dynacell/src/dynacell/distribution/__init__.py @@ -0,0 +1,22 @@ +"""Distribution-side packaging for DynaCell datasets. + +Wraps :mod:`iohub.core.ozx` to pack assembled OME-Zarr stores into +RFC-9 ``.ozx`` archives suitable for one-line download from S3 +(AWS Open Data hosts) and reviewer-sample fixtures. +""" + +from dynacell.distribution.manifest import ( + PackManifest, + write_pack_manifest, +) +from dynacell.distribution.ozx import ( + PackResult, + pack_dataset, +) + +__all__ = [ + "PackManifest", + "PackResult", + "pack_dataset", + "write_pack_manifest", +] diff --git a/applications/dynacell/src/dynacell/distribution/cli.py b/applications/dynacell/src/dynacell/distribution/cli.py new file mode 100644 index 000000000..18147634d --- /dev/null +++ b/applications/dynacell/src/dynacell/distribution/cli.py @@ -0,0 +1,180 @@ +"""``distribute`` subcommand entry points. + +Wired into the ``dynacell`` top-level dispatcher (``_ARGPARSE_COMMANDS`` +in ``dynacell/__main__.py``). The retired ``dynacell-paper`` console +script this originally targeted was removed by the Phase 13 migration. +The dispatcher strips its own subcommand token from ``sys.argv`` +before invoking ``main()``, so by the time argparse runs here +``sys.argv[1:]`` holds the distribute-side flags. +""" + +import argparse +import sys +from pathlib import Path + + +def main() -> None: + """Route ``dynacell distribute {pack|sample|checksum}`` to handlers.""" + parser = argparse.ArgumentParser(prog="dynacell distribute") + sub = parser.add_subparsers(dest="action", required=True) + + pack = sub.add_parser("pack", help="Pack a dataset's assembled zarrs into OZX.") + pack.add_argument( + "dataset", + help="Registered dataset name (e.g. aics-hipsc, a549-mantis-2024_11_07).", + ) + pack.add_argument( + "--output-root", + required=True, + type=Path, + help="Top-level output directory; OZX files land at ///.", + ) + pack.add_argument( + "--targets", + help="Comma-separated subset of targets to pack (default: every target).", + ) + pack.add_argument( + "--splits", + default="train,test", + help="Comma-separated splits to pack (default: train,test).", + ) + pack.add_argument("--overwrite", action="store_true") + + sample = sub.add_parser( + "sample", + help="Pack a small subset (FOV/T-bounded) for reviewer downloads.", + ) + sample.add_argument("dataset") + sample.add_argument("--output-root", required=True, type=Path) + sample.add_argument("--max-fovs", required=True, type=int, dest="fov_limit") + sample.add_argument("--max-t", required=True, type=int, dest="t_limit") + sample.add_argument("--targets") + sample.add_argument("--splits", default="train,test") + sample.add_argument("--overwrite", action="store_true") + + checksum = sub.add_parser( + "checksum", + help=( + "Print sha256 + path for every .ozx under a directory " + "(diagnostic; does not emit MANIFEST.json — that's " + "written by `pack`)." + ), + ) + checksum.add_argument("root", type=Path) + + sync = sub.add_parser( + "sync", + help="Sync a local directory to an S3 bucket (dry-run by default).", + ) + sync.add_argument("local_root", type=Path) + sync.add_argument("--bucket", required=True) + sync.add_argument("--prefix", required=True) + sync.add_argument( + "--no-dry-run", + action="store_true", + dest="no_dry_run", + help="Actually transfer bytes (default: dry-run).", + ) + + verify = sub.add_parser( + "verify-public", + help="Head-check every contentUrl in a Croissant doc (anonymous S3 access).", + ) + verify.add_argument("croissant_path", type=Path) + + args = parser.parse_args(sys.argv[1:]) + + if args.action in ("pack", "sample"): + _do_pack(args) + elif args.action == "checksum": + _do_checksum(args) + elif args.action == "sync": + _do_sync(args) + elif args.action == "verify-public": + _do_verify_public(args) + + +def _do_pack(args: argparse.Namespace) -> None: + """Pack (or sample-pack) one dataset; writes per-dataset MANIFEST.json.""" + from dynacell.distribution.manifest import write_pack_manifest + from dynacell.distribution.ozx import PackMode, pack_dataset + + targets = _split_csv(args.targets) + splits = _split_csv(args.splits) + mode: PackMode = "sample" if args.action == "sample" else "all" + fov_limit = getattr(args, "fov_limit", None) + t_limit = getattr(args, "t_limit", None) + + results = pack_dataset( + args.dataset, + output_root=args.output_root, + mode=mode, + fov_limit=fov_limit, + t_limit=t_limit, + overwrite=args.overwrite, + targets=targets, + splits=splits, + ) + + manifest_path = args.output_root / args.dataset / "MANIFEST.json" + write_pack_manifest(args.dataset, results, manifest_path) + + for r in results: + print(f"Packed {r.dst_ozx_path} sha256={r.sha256[:12]}… bytes={r.bytes}") + print(f"Wrote {manifest_path}") + + +def _do_checksum(args: argparse.Namespace) -> None: + """Recompute sha256 for every .ozx under a directory; print one line each.""" + import hashlib + + for path in sorted(args.root.rglob("*.ozx")): + digest = hashlib.sha256() + with path.open("rb") as fh: + while chunk := fh.read(1 << 20): + digest.update(chunk) + print(f"{digest.hexdigest()} {path}") + + +def _do_sync(args: argparse.Namespace) -> None: + """Run aws s3 sync with explicit dry-run gating.""" + from dynacell.distribution.sync import sync_to_s3 + + code = sync_to_s3( + args.local_root, + bucket=args.bucket, + prefix=args.prefix, + dry_run=not args.no_dry_run, + ) + if code != 0: + sys.exit(code) + + +def _do_verify_public(args: argparse.Namespace) -> None: + """Head-check every contentUrl; exit non-zero if any URL is not 'ok'.""" + from dynacell.distribution.verify import verify_public + + statuses = verify_public(args.croissant_path) + bad = [] + for url, status in statuses.items(): + line = f"{status:>20} {url}" + print(line) + if status not in ("ok", "skip (non-s3 URL)"): + bad.append(url) + if bad: + sys.exit(1) + + +def _split_csv(raw: str | None) -> list[str] | None: + """Split a comma-separated CLI arg into stripped, non-empty tokens. + + Returns ``None`` when ``raw`` is falsy so downstream call sites can + distinguish "user asked for everything" from "user passed an empty + list" — both ``--targets ""`` and an entirely-whitespace value + collapse to ``None`` (treated as "no filter"). + """ + if not raw: + return None + tokens = [tok.strip() for tok in raw.split(",")] + cleaned = [tok for tok in tokens if tok] + return cleaned or None diff --git a/applications/dynacell/src/dynacell/distribution/manifest.py b/applications/dynacell/src/dynacell/distribution/manifest.py new file mode 100644 index 000000000..ce52a47a4 --- /dev/null +++ b/applications/dynacell/src/dynacell/distribution/manifest.py @@ -0,0 +1,102 @@ +"""Per-dataset MANIFEST.json emission for packed OZX trees. + +The MANIFEST.json sits next to a dataset's packed OZX files and +records sha256 + size + ozx_version per archive. Croissant builders +read it to populate ``cr:FileObject.sha256`` + ``contentSize``. +""" + +import dataclasses +import json +from pathlib import Path + +from dynacell.distribution.ozx import PackResult + + +@dataclasses.dataclass(frozen=True) +class PackManifest: + """In-memory representation of a per-dataset OZX MANIFEST.json.""" + + dataset: str + entries: list[dict] + + def to_json(self) -> str: + """Serialize as deterministic, sort-keys JSON for git-friendly diffs.""" + return json.dumps( + {"dataset": self.dataset, "entries": self.entries}, + sort_keys=True, + indent=2, + ) + + +def write_pack_manifest( + dataset: str, + results: list[PackResult], + output_path: Path, +) -> Path: + """Write a per-dataset MANIFEST.json from a list of pack results. + + Parameters + ---------- + dataset + Registered dataset name (e.g. ``"aics-hipsc"``). + results + Output of :func:`pack_dataset`. One entry per packed file. + output_path + Where to write MANIFEST.json. Parent directory created if + absent. + + Returns + ------- + Path + Resolved path to the written manifest. + + Notes + ----- + Writing is a **merge**, not a full rebuild: a split-scoped pack + (``pack --splits train`` then ``pack --splits test``) must not leave a + manifest that omits the archive the earlier call produced. Prior entries + survive only while their ``.ozx`` is still on disk, so a ledger whose whole + job is checksums never keeps a row for an archive that has been deleted. + Entries this call produced always win over a prior row for the same + destination. + """ + entries = [ + { + "target": r.target, + "split": r.split, + "src_zarr_path": str(r.src_zarr_path), + "dst_ozx_path": str(r.dst_ozx_path.resolve()), + "bytes": r.bytes, + "sha256": r.sha256, + "ozx_version": r.ozx_version, + } + for r in results + ] + entries = _merge_with_existing(entries, output_path) + manifest = PackManifest(dataset=dataset, entries=entries) + output_path.parent.mkdir(parents=True, exist_ok=True) + output_path.write_text(manifest.to_json() + "\n") + return output_path.resolve() + + +def _merge_with_existing(entries: list[dict], output_path: Path) -> list[dict]: + """Fold surviving prior entries into ``entries`` and order deterministically. + + Parameters + ---------- + entries + Rows built from the current call's pack results. + output_path + MANIFEST.json being written. Absent on a first pack. + + Returns + ------- + list of dict + Merged rows sorted by ``(split, target)`` so a re-pack of the same + archives is a no-op diff. + """ + if output_path.exists(): + prior = json.loads(output_path.read_text())["entries"] + fresh = {e["dst_ozx_path"] for e in entries} + entries = [e for e in prior if e["dst_ozx_path"] not in fresh and Path(e["dst_ozx_path"]).exists()] + entries + return sorted(entries, key=lambda e: (e["split"], e["target"])) diff --git a/applications/dynacell/src/dynacell/distribution/ozx.py b/applications/dynacell/src/dynacell/distribution/ozx.py new file mode 100644 index 000000000..793ff7123 --- /dev/null +++ b/applications/dynacell/src/dynacell/distribution/ozx.py @@ -0,0 +1,320 @@ +"""Pack assembled OME-Zarr stores into RFC-9 ``.ozx`` archives. + +Wraps :func:`iohub.core.ozx.pack_ozx` (1:1 zip-pack of a directory zarr +store, RFC-9 compliant — see iohub PR #408) with two extras the bare +API does not provide: + +- **Sample mode**: a subset writer that copies a bounded number of FOVs + and timepoints into a tmp zarr before packing — needed for the + NeurIPS ``<4 GB`` reviewer sample. +- **Manifest emission**: writes per-dataset MANIFEST.json with sha256 + + size + ozx_version per packed file. Stream B's output is Stream A's + input (Croissant ``cr:FileObject.sha256`` populated from this). +""" + +import dataclasses +import datetime +import hashlib +import shutil +import tempfile +from pathlib import Path +from typing import Literal + +from iohub.core.ozx import ( + OZX_EXTENSION, + is_ozx_path, + pack_ozx, + read_ozx_version, +) +from iohub.ngff import TransformationMeta + +from dynacell.data import get_manifest + +PackMode = Literal["all", "sample"] + +__all__ = [ + "OZX_EXTENSION", + "PackMode", + "PackResult", + "is_ozx_path", + "pack_dataset", + "read_ozx_version", +] + +_BUF_SIZE = 1 << 20 # 1 MiB chunks for sha256 streaming. + +# `StoreLocations` fields that are data splits rather than auxiliary artifacts. +# A requested core split with no store is an error; the auxiliary fields +# (`cell_segmentation`, `gt_cache_dir`) are legitimately unset per target. +_CORE_SPLITS: frozenset[str] = frozenset({"train", "test"}) + + +@dataclasses.dataclass(frozen=True) +class PackResult: + """Single ``(target, split)`` packed OZX result. + + Attributes + ---------- + dataset + Registered dataset name (e.g. ``"aics-hipsc"``). + target + Target key within the manifest (e.g. ``"sec61b"``). + split + ``"train"`` or ``"test"``. + src_zarr_path + Source OME-Zarr directory (the assembled store). + dst_ozx_path + Output ``.ozx`` archive. + bytes + Size of the resulting archive in bytes. + sha256 + Hex digest of the OZX file. + ozx_version + OME-NGFF version stamped in the OZX archive comment. + """ + + dataset: str + target: str + split: str + src_zarr_path: Path + dst_ozx_path: Path + bytes: int + sha256: str + ozx_version: str | None + + +def pack_dataset( + name: str, + *, + output_root: Path, + mode: PackMode = "all", + fov_limit: int | None = None, + t_limit: int | None = None, + overwrite: bool = False, + targets: list[str] | None = None, + splits: list[str] | None = None, +) -> list[PackResult]: + """Pack one registered dataset's assembled zarrs into OZX archives. + + Parameters + ---------- + name + Registered dataset name (must resolve via + :func:`dynacell.data.get_manifest`). + output_root + Top-level output directory; OZX files land at + ``///.ozx``. The path + layout mirrors the source store layout from the manifest. + mode + ``"all"`` packs the full source zarr 1:1. ``"sample"`` writes + a subset zarr (limited by ``fov_limit`` and ``t_limit``) to a + tmp directory then packs that — ``pack_ozx`` itself does not + sub-select. + fov_limit, t_limit + Per-axis limits in sample mode. Ignored in ``"all"`` mode. + overwrite + Replace any existing destination ``.ozx``. + targets, splits + Optional filters. Default: every target × ``{train, test}``. + + Returns + ------- + list[PackResult] + One entry per unique ``(physical_source, split)`` pair. Targets + sharing a physical source store (e.g. aics-hipsc nucleus + + membrane both reference ``cell.zarr``) are de-duplicated to a + single PackResult. + """ + manifest = get_manifest(name) + requested_targets = list(targets) if targets is not None else list(manifest.targets) + requested_splits = list(splits) if splits is not None else ["train", "test"] + + # Validate targets + splits up front so a typo (e.g. "tran" instead + # of "train") fails loudly rather than silently producing zero + # outputs because getattr(...None) would otherwise skip the missing + # attribute. Split names must match a `StoreLocations` field. + unknown_targets = [t for t in requested_targets if t not in manifest.targets] + if unknown_targets: + raise ValueError( + f"Unknown targets {unknown_targets!r} for dataset {name!r}; available: {sorted(manifest.targets)}" + ) + sample_target = next(iter(manifest.targets.values())) + valid_split_fields = set(type(sample_target.stores).model_fields) + unknown_splits = [s for s in requested_splits if s not in valid_split_fields] + if unknown_splits: + raise ValueError(f"Unknown splits {unknown_splits!r}; available: {sorted(valid_split_fields)}") + + # `train` / `test` are the data splits a pack request means literally, and + # `train` is optional on evaluation-only manifests (hek-mantis-*). Without + # this check the per-split loop below would hit its `src is None` branch -- + # written for the auxiliary fields -- and silently emit a manifest missing + # the split the caller asked for (the CLI requests train,test by default). + missing_core = [ + f"{target_key}/{split}" + for split in requested_splits + if split in _CORE_SPLITS + for target_key in requested_targets + if getattr(manifest.targets[target_key].stores, split) is None + ] + if missing_core: + raise ValueError( + f"Dataset {name!r} has no store for requested split(s) {missing_core!r}. " + "Evaluation-only datasets define no train store — pass --splits test." + ) + + seen_sources: dict[Path, PackResult] = {} + results: list[PackResult] = [] + + for target_key in requested_targets: + target = manifest.targets[target_key] + for split in requested_splits: + src = getattr(target.stores, split, None) + if src is None: + # The split is a valid StoreLocations field (validated + # above) but this target left it unset (e.g. + # `cell_segmentation` is optional); skip silently. + continue + src_path = Path(src) + if not src_path.exists(): + raise FileNotFoundError(f"Source store missing: {src_path} ({name}/{target_key}/{split})") + if src_path in seen_sources: + # Dedup: shared store across targets emits one OZX. + continue + # mode="sample" MUST NOT collide with the full archive. The + # `_sample` suffix used to live only on the throwaway tmp zarr, so + # `pack ` followed by `sample --overwrite` into the same + # --output-root replaced a multi-GB release archive with a 2-FOV + # reviewer subset -- and write_pack_manifest then recorded the + # sample's sha256/bytes as the dataset's. + stem = f"{src_path.stem}_sample" if mode == "sample" else src_path.stem + dst_path = output_root / name / split / f"{stem}.ozx" + result = _pack_one( + dataset=name, + target=target_key, + split=split, + src_path=src_path, + dst_path=dst_path, + mode=mode, + fov_limit=fov_limit, + t_limit=t_limit, + overwrite=overwrite, + ) + seen_sources[src_path] = result + results.append(result) + return results + + +def _pack_one( + *, + dataset: str, + target: str, + split: str, + src_path: Path, + dst_path: Path, + mode: PackMode, + fov_limit: int | None, + t_limit: int | None, + overwrite: bool, +) -> PackResult: + """Pack a single source zarr into one OZX archive.""" + if dst_path.exists(): + if not overwrite: + raise FileExistsError(f"Destination already exists: {dst_path}; pass overwrite=True") + dst_path.unlink() + dst_path.parent.mkdir(parents=True, exist_ok=True) + + if mode == "sample": + if fov_limit is None or t_limit is None: + raise ValueError("sample mode requires both fov_limit and t_limit") + with _subset_zarr(src_path, fov_limit=fov_limit, t_limit=t_limit) as subset_path: + pack_ozx(subset_path, dst_path) + else: + pack_ozx(src_path, dst_path) + + return PackResult( + dataset=dataset, + target=target, + split=split, + src_zarr_path=src_path, + dst_ozx_path=dst_path, + bytes=dst_path.stat().st_size, + sha256=_sha256_file(dst_path), + ozx_version=read_ozx_version(dst_path), + ) + + +def _sha256_file(path: Path) -> str: + """Stream the file through sha256 in 1 MiB chunks.""" + digest = hashlib.sha256() + with path.open("rb") as fh: + while chunk := fh.read(_BUF_SIZE): + digest.update(chunk) + return digest.hexdigest() + + +def _now_iso() -> str: + """UTC timestamp without microseconds for MANIFEST.json determinism debug.""" + return datetime.datetime.now(datetime.timezone.utc).replace(microsecond=0).isoformat() + + +class _subset_zarr: + """Context manager that writes a subset zarr to a tmp dir for sample-mode pack. + + Iohub's ``pack_ozx`` is a 1:1 archive; this helper handles the + subset-extraction step. Only HCS plate sources are supported (the + only layout dynacell-paper produces). + """ + + def __init__( + self, + src_path: Path, + *, + fov_limit: int, + t_limit: int, + ) -> None: + self.src_path = src_path + self.fov_limit = fov_limit + self.t_limit = t_limit + self.tmp_dir: Path | None = None + + def __enter__(self) -> Path: + from iohub.ngff import open_ome_zarr + + self.tmp_dir = Path(tempfile.mkdtemp(prefix="dynacell-ozx-sample-")) + dst_zarr = self.tmp_dir / f"{self.src_path.stem}_sample.zarr" + + with open_ome_zarr(self.src_path, mode="r", layout="hcs") as src: + channel_names = src.channel_names + with open_ome_zarr( + dst_zarr, + mode="w-", + layout="hcs", + channel_names=channel_names, + ) as dst: + for i, (pos_name, src_pos) in enumerate(src.positions()): + if i >= self.fov_limit: + break + src_arr = src_pos["0"] + t_take = min(self.t_limit, src_arr.shape[0]) + sub = src_arr[:t_take, ...] + dst_pos = dst.create_position(*pos_name.split("/")) + # Carry the source voxel size through. Without an explicit + # transform iohub writes scale=[1,1,1,1,1], so a sample of a + # [1, 1, 0.174, 0.1494, 0.1494] store would publish itself as + # isotropic 1 um -- a 5.8x Z error in a released artifact. + dst_pos.create_image( + "0", + sub, + chunks=src_arr.chunks, + transform=[TransformationMeta(type="scale", scale=list(src_pos.scale))], + ) + # Non-OME per-position attrs (normalization, focus_slice, + # hpi_values, ...) are not copied by create_position; the + # eval path reads several of them with .get(), so dropping + # them degrades silently rather than raising. + dst_pos.zattrs.update({k: v for k, v in dict(src_pos.zattrs).items() if k != "ome"}) + return dst_zarr + + def __exit__(self, *exc: object) -> None: + if self.tmp_dir is not None and self.tmp_dir.exists(): + shutil.rmtree(self.tmp_dir) diff --git a/applications/dynacell/src/dynacell/distribution/sync.py b/applications/dynacell/src/dynacell/distribution/sync.py new file mode 100644 index 000000000..b8e9b1a8d --- /dev/null +++ b/applications/dynacell/src/dynacell/distribution/sync.py @@ -0,0 +1,69 @@ +"""S3 sync wrapper for AWS Open Data uploads. + +Wraps the AWS CLI's ``aws s3 sync`` (out-of-band installation; not a +Python dependency). Default mode is dry-run; explicit ``--no-dry-run`` +is required to write — S3 is a shared system and an unintended sync +can move terabytes. +""" + +import shutil +import subprocess +from pathlib import Path + + +def sync_to_s3( + local_root: Path, + bucket: str, + prefix: str, + *, + dry_run: bool = True, + extra_args: list[str] | None = None, +) -> int: + """Run ``aws s3 sync s3:///``. + + Parameters + ---------- + local_root + Local directory to sync. + bucket + Target bucket name (without ``s3://``). + prefix + Key prefix inside the bucket. + dry_run + When True (default), passes ``--dryrun`` to the AWS CLI so the + command prints what *would* sync without actually transferring + bytes. Required to be flipped explicitly to ``False`` by the + caller to avoid accidental writes. + extra_args + Additional flags to pass to the AWS CLI (e.g. + ``["--exclude", "*.tmp"]``). + + Returns + ------- + int + AWS CLI exit code. 0 == success. + + Raises + ------ + RuntimeError + If the ``aws`` CLI is not on ``$PATH``. + FileNotFoundError + If ``local_root`` does not exist or is not a directory. + """ + if shutil.which("aws") is None: + raise RuntimeError("aws CLI not on PATH; install via brew/apt (or: pip install awscli) before invoking sync") + if not local_root.is_dir(): + raise FileNotFoundError(f"local_root must be an existing directory: {local_root}") + cmd = [ + "aws", + "s3", + "sync", + str(local_root), + f"s3://{bucket}/{prefix}", + ] + if dry_run: + cmd.append("--dryrun") + if extra_args: + cmd.extend(extra_args) + print(f"+ {' '.join(cmd)}") + return subprocess.run(cmd, check=False).returncode diff --git a/applications/dynacell/src/dynacell/distribution/verify.py b/applications/dynacell/src/dynacell/distribution/verify.py new file mode 100644 index 000000000..eb73589a4 --- /dev/null +++ b/applications/dynacell/src/dynacell/distribution/verify.py @@ -0,0 +1,123 @@ +"""Public-URL smoke for committed Croissant ``contentUrl`` fields. + +NeurIPS 2026 E&D submissions risk desk-rejection when Croissant URLs +do not resolve at submission time. ``verify_public`` issues an +unauthenticated ``head_object`` against every URL in a Croissant doc +to catch 403/404 before reviewers do. +""" + +import json +from pathlib import Path +from typing import Any +from urllib.parse import urlparse + + +def _iter_content_urls(jsonld: dict[str, Any]) -> list[str]: + """Walk a Croissant JSON-LD doc and yield every ``contentUrl`` string. + + Parameters + ---------- + jsonld : dict + Parsed Croissant document. + + Returns + ------- + list of str + Every ``contentUrl`` found under ``distribution``. + + Raises + ------ + KeyError + If the doc has no ``distribution`` key. Defaulting to ``[]`` made a + missing, renamed or ``@graph``-wrapped key indistinguishable from a + doc with nothing to check: ``verify-public`` then printed nothing and + exited 0, reporting success having verified no URL at all. Every + producer in this codebase sets ``distribution`` unconditionally + (``builder.py`` and ``merge_croissant_docs``), so its absence means + the doc is not what this tool expects. + """ + urls: list[str] = [] + distribution = jsonld["distribution"] + if isinstance(distribution, list): + for item in distribution: + if isinstance(item, dict): + url = item.get("contentUrl") + if isinstance(url, str): + urls.append(url) + return urls + + +def verify_public(croissant_path: Path) -> dict[str, str]: + """Head-check every ``s3://`` URL in a Croissant doc; return a status map. + + Parameters + ---------- + croissant_path + Path to a Croissant JSON-LD file + (e.g. ``preprocessing/dynacell-a549/4-pack-ozx/croissant_a549.json``). + + Returns + ------- + dict[str, str] + ``{url: status}``. Documented status values: + + - ``"ok"`` — head_object returned 200. + - ``"skip (non-s3 URL)"`` — non-``s3://`` URL (https links to + landing pages, etc.); not exercised here. + - ``"missing-bucket"`` — malformed ``s3://`` URL (no bucket + host or empty key). + - Any AWS error code from + ``ClientError.response["Error"]["Code"]`` (commonly + ``"404"``, ``"403"``, ``"NoSuchKey"``, ``"AccessDenied"``). + - Any unexpected exception's class name as a fallback. + + Caller checks for non-``"ok"``/non-``"skip"`` values and exits + non-zero. + + Raises + ------ + RuntimeError + If ``boto3`` is not installed (unauthenticated S3 head requires + the AWS SDK; the AWS CLI alone won't work for arbitrary + anonymous access against not-yet-public buckets). + + Notes + ----- + Only ``s3://`` URLs are verified. ``https://`` URLs (e.g. the + landing page) are out of scope — verify those manually with a + browser before submission. + """ + try: + import boto3 + import botocore + except ImportError as exc: + raise RuntimeError( + "boto3 not installed; install the distribution extra (uv sync --extra distribution) for verify_public" + ) from exc + + payload = json.loads(croissant_path.read_text()) + urls = _iter_content_urls(payload) + s3 = boto3.client( + "s3", + config=botocore.client.Config(signature_version=botocore.UNSIGNED), + ) + statuses: dict[str, str] = {} + for url in urls: + if not url.startswith("s3://"): + statuses[url] = "skip (non-s3 URL)" + continue + parsed = urlparse(url) + bucket = parsed.netloc + key = parsed.path.lstrip("/") + if not bucket or not key: + statuses[url] = "missing-bucket" + continue + try: + s3.head_object(Bucket=bucket, Key=key) + statuses[url] = "ok" + except botocore.exceptions.ClientError as exc: + code = exc.response.get("Error", {}).get("Code", "unknown") + statuses[url] = code + except Exception as exc: # pragma: no cover — surface unexpected + statuses[url] = f"{type(exc).__name__}: {exc}" + return statuses diff --git a/applications/dynacell/src/dynacell/engine.py b/applications/dynacell/src/dynacell/engine.py index a9cfbd075..1eb75db8c 100644 --- a/applications/dynacell/src/dynacell/engine.py +++ b/applications/dynacell/src/dynacell/engine.py @@ -9,16 +9,20 @@ import inspect import itertools import logging +from collections.abc import Callable from typing import Literal, Sequence import numpy as np import torch import torch.nn.functional as F -from lightning.pytorch import LightningModule +from lightning.pytorch import Callback, LightningModule +from lightning.pytorch.trainer.states import TrainerFn from monai.transforms import DivisiblePad from torch import Tensor, nn from dynacell.celldiff_wrapper import CELLDiff3DVS +from dynacell.mask_conditioning import CondMaskSource, MaskCorruption, binarize_mask, encode_mask +from dynacell.tiling import window_starts from viscy_data import Sample from viscy_models import Unet3d, UNeXt2 from viscy_models.celldiff import CELLDiffNet, UNetViT3D @@ -35,6 +39,7 @@ ) from viscy_models.unet.fcmae import FullyConvolutionalMAE from viscy_utils.log_images import detach_sample, log_image_grid +from viscy_utils.losses import BackgroundLowPass, SegAuxDice, SegConsistencyLoss from viscy_utils.optimizers import configure_adamw_scheduler _logger = logging.getLogger("lightning.pytorch") @@ -47,6 +52,20 @@ } +def _ckpt_state_dict(ckpt_path: str) -> dict[str, Tensor]: + """Load only the ``state_dict`` of a Lightning checkpoint onto CPU.""" + return torch.load(ckpt_path, weights_only=True, map_location="cpu")["state_dict"] + + +def _record_val_loss( + losses: list[list[tuple[Tensor, int]]], dataloader_idx: int, loss: Tensor, batch_size: int +) -> None: + """Append ``(loss, batch_size)`` to ``losses[dataloader_idx]``, growing the list first.""" + while len(losses) <= dataloader_idx: + losses.append([]) + losses[dataloader_idx].append((loss, batch_size)) + + def _aggregate_validation_losses( validation_losses: list[list[tuple[Tensor, int]]], ) -> Tensor: @@ -82,6 +101,94 @@ def _log_samples(module: LightningModule, key: str, imgs: Sequence[Sequence[np.n log_image_grid(module.logger, key, imgs, module.current_epoch) +def _check_seg_aux_args( + seg_aux: SegAuxDice | None, seg_aux_weight: float, base_loss: nn.Module, base_accepts_fg_mask: bool +) -> None: + """Reject ``seg_aux`` configurations whose meaning would be silently different. + + A weight without the module does nothing; and a base loss that accepts + ``fg_mask`` (v1 ``SpotlightLoss``) would be called without it once the mask + belongs to the aux term, silently switching it to its own runtime mask. + """ + if seg_aux is None: + if seg_aux_weight != 0.0: + raise ValueError(f"seg_aux_weight={seg_aux_weight} has no effect without seg_aux.") + return + if base_accepts_fg_mask: + raise ValueError( + f"seg_aux consumes fg_mask, so the base loss is called without it; " + f"{type(base_loss).__name__} accepts fg_mask and would change meaning. " + "Use a mask-free base loss (e.g. MSELoss, L1Loss, MixedLoss) with seg_aux." + ) + + +def _check_seg_consistency_args( + seg_consistency: SegConsistencyLoss | None, weight: float | None, seg_aux: SegAuxDice | None +) -> None: + """Reject a ``seg_consistency`` weight without the term, the term without a weight, and it with ``seg_aux``. + + The weight has no default: it is calibrated per cell (median over validation + batches of ``||grad base|| / ||grad seg_consistency||`` at the starting + checkpoint), so a config that sets the term must also set its weight. + With ``seg_aux`` too, the logged ``base`` would stop meaning the loss before the term. + """ + if seg_consistency is None: + if weight is not None: + raise ValueError(f"seg_consistency_weight={weight} has no effect without seg_consistency.") + return + if weight is None: + raise ValueError( + "seg_consistency is set without seg_consistency_weight, which has no default: calibrate it as the " + "median gradient-norm ratio ||grad base|| / ||grad seg_consistency|| at the starting checkpoint." + ) + if weight <= 0: + raise ValueError(f"seg_consistency_weight must be > 0, got {weight}; drop seg_consistency to turn it off") + if seg_aux is not None: + raise ValueError("seg_consistency cannot be combined with seg_aux; use one auxiliary term per arm.") + + +def _require_fg_mask(batch: Sample) -> Tensor: + """Return the batch's ``fg_mask`` or raise naming the missing config.""" + if "fg_mask" not in batch: + raise KeyError( + "seg_aux, mask_mode or target_bg_lowpass is set but the batch has no 'fg_mask'. Set fg_mask_key " + "on the datamodule (the store needs a generate_fg_masks array) or drop seg_aux / mask_mode / " + "target_bg_lowpass." + ) + return batch["fg_mask"] + + +def _check_mask_mode_args( + mask_mode: str | None, + net_kwargs: dict, + seg_aux: SegAuxDice | None, + mask_velocity_weight: float, + mask_dice_weight: float, + mask_corruption: MaskCorruption | None, + cond_mask_source: CondMaskSource | None, +) -> None: + """Reject ``mask_mode`` settings that would be silently ignored or ambiguous.""" + if mask_mode not in (None, "joint", "cond"): + raise ValueError(f"mask_mode must be None, 'joint' or 'cond', got {mask_mode!r}") + if mask_mode != "joint" and (mask_velocity_weight != 1.0 or mask_dice_weight != 0.0): + raise ValueError("mask_velocity_weight and mask_dice_weight apply only to mask_mode='joint'.") + if mask_mode != "cond" and (mask_corruption is not None or cond_mask_source is not None): + raise ValueError("mask_corruption and cond_mask_source apply only to mask_mode='cond'.") + cond_channels = net_kwargs.get("cond_channels", 1) + if mask_mode == "cond" and cond_channels < 2: + raise ValueError(f"mask_mode='cond' needs net_config.cond_channels >= 2 (phase + mask), got {cond_channels}") + if mask_mode != "cond" and cond_channels != 1: + raise ValueError(f"net_config.cond_channels={cond_channels} needs mask_mode='cond'.") + if mask_mode == "joint": + if seg_aux is not None: + raise ValueError("mask_mode='joint' scores the generated mask channel; use mask_dice_weight, not seg_aux.") + if mask_velocity_weight < 0 or mask_dice_weight < 0: + raise ValueError( + f"mask weights must be >= 0, got mask_velocity_weight={mask_velocity_weight}, " + f"mask_dice_weight={mask_dice_weight}" + ) + + def _make_divisible_pad(model: nn.Module) -> DivisiblePad: """Build a DivisiblePad matching the model's spatial downsampling axes. @@ -115,6 +222,340 @@ def _center_crop_to_shape(tensor: Tensor, spatial_shape: tuple[int, ...]) -> Ten return tensor[tuple(slices)] +def _blend_weight( + patch_spatial: tuple[int, ...], + device: torch.device, + dtype: torch.dtype, + eps: float = 1e-3, +) -> Tensor: + """Separable raised-cosine (Hann) taper over one window, floored at ``eps``. + + Weight is ~1 at the window centre and falls smoothly to ``eps`` at its + faces, so a window contributes least exactly where it knows least (its + own border) and adjacent windows cross-fade instead of butt-joining. + + The ``eps`` floor keeps every weight strictly positive, which matters for + two reasons: the normalization in + :func:`_sliding_window_inference` cannot divide by zero, and voxels that + only ever fall on a window face (the volume's outer border) still get + their value from the one window that covers them. + + Parameters + ---------- + patch_spatial : tuple of int + Window size per spatial dimension. + device : torch.device + Device for the returned tensor. + dtype : torch.dtype + Dtype for the returned tensor. + eps : float + Lower bound on the taper. + + Returns + ------- + Tensor + Weight of shape ``(1, 1, *patch_spatial)``. + """ + weight = torch.ones([1, 1, *patch_spatial], device=device, dtype=dtype) + for axis, size in enumerate(patch_spatial): + if size <= 1: + continue + index = torch.arange(size, device=device, dtype=dtype) + taper = (0.5 - 0.5 * torch.cos(2 * torch.pi * (index + 0.5) / size)).clamp_min(eps) + shape = [1, 1] + [1] * len(patch_spatial) + shape[2 + axis] = size + weight = weight * taper.reshape(shape) + return weight + + +def _sliding_window_inference( + forward_fn: Callable[[Tensor], Tensor], + source: Tensor, + patch_spatial: tuple[int, ...], + overlap_size: tuple[int, int, int] = (4, 256, 256), + blend: Literal["cosine", "uniform"] = "cosine", +) -> Tensor: + """Tile ``source`` into ``patch_spatial`` windows, run ``forward_fn`` per tile, blend overlaps. + + Fixed-input-size generators (the ViT ``UNetViT3D``) cannot run a forward + pass on a volume larger than their trained spatial size. This slides + ``patch_spatial`` windows over the ``(D, H, W)`` extent of ``source`` and + combines predictions in overlapping regions, yielding a prediction with the + same spatial shape as ``source``. The channel dimension is taken from the + forward output (``out_channels`` may differ from ``source``'s in_channels). + + Overlaps are combined as a weighted mean ``sum(w * out) / sum(w)``. + + ``blend='uniform'`` uses ``w = 1`` everywhere, i.e. a plain average over + the windows covering each voxel. That prints visible seams: the number of + covering windows changes abruptly across a window face (on a 640x960 FOV + with patch 512 / overlap 256 the count steps 1->2->3->2->1), so wherever + adjacent windows disagree the count change appears as a step. Measured on + an A549 TOMM20 prediction, the mean absolute row-to-row step at the y=128 + window edge was 7.4x its local median, versus 1.0x for the ground truth. + + ``blend='cosine'`` (default) weights each window by :func:`_blend_weight`, + which cross-fades neighbours and removed those spikes entirely + (7.4x -> 1.0x at y=128; 5.4x -> 1.3x at x=256), while slightly improving + agreement with ground truth. Prefer it unless reproducing a legacy + prediction exactly. + + Because the combination is a *normalized* weighted mean, both modes are + identical wherever a single window covers a voxel -- in particular the + whole volume when ``source`` matches ``patch_spatial`` (the 512x512 iPSC + test set), where neither mode changes anything. + + Parameters + ---------- + forward_fn : Callable + Maps one ``(B, C, *patch_spatial)`` tile to ``(B, out_channels, *patch_spatial)``. + source : Tensor + Input tensor of shape ``(B, C, D, H, W)``. + patch_spatial : tuple of int + Per-dimension window size ``(pd, ph, pw)`` (the model's ``input_spatial_size``). + overlap_size : tuple of int + Overlap in ``(D, H, W)`` between adjacent windows. + blend : {"cosine", "uniform"} + Overlap weighting, as described above. + + Returns + ------- + Tensor + Prediction with the same spatial shape as ``source``. + + Raises + ------ + ValueError + If ``blend`` is not one of the two supported modes. + """ + if blend not in ("cosine", "uniform"): + raise ValueError(f"Unknown blend {blend!r}; choose 'cosine' or 'uniform'.") + n_spatial = 3 + patch = tuple(patch_spatial) + start_lists = window_starts(tuple(source.shape[-3:]), patch, overlap_size) + + # Accumulators are allocated lazily from the first patch output so their + # channel dimension matches the model's out_channels (which can differ + # from source's in_channels, e.g. 1 phase in -> 2 target out). + prediction_sum: Tensor | None = None + weight_sum: Tensor | None = None + weight: Tensor | None = None + output_dtype: torch.dtype | None = None + + with torch.no_grad(): + for starts in itertools.product(*start_lists): + slicer: list = [slice(None)] * source.ndim + for i, st in enumerate(starts): + slicer[-(n_spatial - i)] = slice(st, st + patch[i]) + patch_out = forward_fn(source[tuple(slicer)]) + if prediction_sum is None: + output_dtype = patch_out.dtype + out_shape = list(source.shape) + out_shape[1] = patch_out.shape[1] + # FP16 Hann products can underflow at corners, and overlapping + # predictions can overflow before the normalized mean is taken. + accumulation_dtype = torch.promote_types(patch_out.dtype, torch.float32) + prediction_sum = torch.zeros(out_shape, device=source.device, dtype=accumulation_dtype) + weight_sum = torch.zeros(out_shape, device=source.device, dtype=accumulation_dtype) + weight = ( + _blend_weight(patch, source.device, accumulation_dtype) + if blend == "cosine" + else torch.ones([1, 1, *patch], device=source.device, dtype=accumulation_dtype) + ) + # Fused multiply-accumulate into the view; promotes half-precision + # patches to the accumulation dtype without a temporary. + prediction_sum[tuple(slicer)].addcmul_(patch_out, weight) + weight_sum[tuple(slicer)] += weight + + if prediction_sum is None: + raise RuntimeError("sliding window produced no patches") + if not torch.all(weight_sum > 0): + raise RuntimeError("sliding window left uncovered voxels") + return prediction_sum.div_(weight_sum).to(output_dtype) + + +def _phase_shift_average( + forward_fn: Callable[[Tensor], Tensor], + source: Tensor, + patch_spatial: tuple[int, ...], + overlap_size: tuple[int, int, int], + offsets: Sequence[int], + blend: Literal["cosine", "uniform"] = "cosine", +) -> Tensor: + """Average tiled predictions over YX shifts of the analysis grid. + + ``UNet3DBase`` decoders upsample with + ``ConvTranspose3d(kernel_size=3, stride=2)``. Kernel 3 is not divisible by + stride 2, so the overlap between kernel placements is uneven and each + upsample imprints a 2-periodic modulation; three stacked upsamples put + energy at 2, 4 and 8 px (Odena et al., "Deconvolution and Checkerboard + Artifacts", 2016). ``UNetViT3D`` adds a second lattice at 32 px, where the + ViT bottleneck's ``unpatchify`` lays independently projected token blocks + side by side. + + Both are present IN distribution, not only out of it. On an iPSC-trained + membrane prediction of an iPSC FOV -- fully in-domain -- folding the mean + ``|gradient|`` profile by index mod 32 and splitting it into harmonics + gives these relative amplitudes, with ground truth as the floor: + + ================ ====== ====== ====== ====== ====== + pure component P32 P16 P8 P4 P2 + ================ ====== ====== ====== ====== ====== + prediction 0.063 0.100 0.076 0.134 0.330 + ground truth 0.025 0.011 0.004 0.002 0.002 + excess 2.5x 8.9x 19.9x 66.8x 215.7x + ================ ====== ====== ====== ====== ====== + + Most of the lattice *energy* sits at the short periods, but the 32 px + component is what a reader sees as blocks: it is a coherent step between + adjacent token cells, and it survives the downsampling any figure applies + to a 512 px field, while the 2-8 px components average away. Out of + distribution all of it grows. + + Both lattices are fixed relative to the *window* origin, not to the + specimen, so predicting on a shifted grid moves them relative to the image + while real structure stays put. Averaging shifts ``o_k`` scales a + period-``P`` lattice by ``|sum_k exp(2*pi*i*o_k/P)| / len(o)``: zero is + exact cancellation, one means the offsets are all congruent mod ``P`` and + the lattice is fully *reinforced*. + + It is tempting to pick offsets that zero that factor at 32, since 32 px is + the visible period. Do not -- it is the wrong objective, because the + offsets must serve every period at once and the short ones carry the + energy. Measured in-domain (iPSC-trained membrane on iPSC; modulation + depth of the 32-bin fold, ground-truth floor 0.0705 at P32 and 0.0041 at + P4; 16 passes each): + + ================== =========== ========== ======== ======= ====== + offsets phasor @32 phasor @4 depth@32 depth@4 PCC + ================== =========== ========== ======== ======= ====== + (none) - - 0.9866 0.5304 0.5378 + (0, 8, 16, 24) 0.000 1.000 0.6412 0.4966 0.5423 + (0, 10, 16, 26) 0.000 0.000 0.5911 0.3787 0.5423 + (0, 5, 11, 22) 0.241 0.000 0.2402 0.0184 0.5406 + ================== =========== ========== ======== ======= ====== + + The two sets that cancel P32 *exactly* come out two to three times worse + than the one that does not, because both are congruent mod 8 (and + ``(0, 8, 16, 24)`` mod 4 and mod 2 as well), so they reinstate the + high-amplitude short-period components while removing the low-amplitude + 32 px one. ``(0, 5, 11, 22)`` zeroes P2 and P4 exactly and holds P8/P16/P32 + at ~0.21-0.27, which is the best available compromise at four offsets -- + no four-offset set gets the worst case over {4, 8, 16, 32} below 0.27. + Prefer it, and re-measure before trusting any replacement: the phasor + factor ranks candidates, it does not rank outcomes. + + Pass the offsets as explicit ``(dy, dx)`` PAIRS to avoid paying for the + outer product. The lattice is separable to first order -- a component that + depends on ``y mod P``, one on ``x mod P``, and a smaller cross term -- so + four pairs whose ``dy`` values and ``dx`` values are each the full offset + set give every axis the same four residues the 16-combination product does, + at a quarter of the cost. Measured on the same FOV and plane: + + ============================== ====== ======== ======= ====== + offsets passes depth@32 depth@4 PCC + ============================== ====== ======== ======= ====== + (none) 1 0.9866 0.5304 0.5378 + outer product of (0,5,11,22) 16 0.2402 0.0184 0.5406 + (0,0) (5,11) (11,22) (22,5) 4 0.2338 0.0172 0.5414 + (0,11) (5,22) (11,0) (22,5) 4 0.2239 0.0190 0.5407 + (0,0) (5,5) (11,11) (22,22) 4 0.2495 0.0174 0.5391 + ============================== ====== ======== ======= ====== + + Every 4-pass set matches the 16-pass product within measurement noise, and + the two off-diagonal ones edge it out -- the diagonal set is marginally the + weakest at period 32, which is the cross term it fails to decorrelate. + + Cost is ``len(offsets) ** 2`` passes for a flat offset list and + ``len(offsets)`` for pairs, which is the only reason this is opt-in rather + than the default: it improved PCC in every case measured (in-domain + membrane 0.5378 -> 0.5406, out-of-distribution ER 0.246 -> 0.272), and the + one case where it slightly *lowered* it was in-domain A549 TOMM20 + (0.533 -> 0.528), where the mean over correlated predictions costs a little + sharpness. Turn it on for any figure panel where the token grid is visible. + + Parameters + ---------- + forward_fn : Callable + Maps one ``(B, C, *patch_spatial)`` tile to ``(B, out_channels, *patch_spatial)``. + source : Tensor + Input tensor of shape ``(B, C, D, H, W)``. + patch_spatial : tuple of int + Per-dimension window size ``(pd, ph, pw)``. + overlap_size : tuple of int + Overlap in ``(D, H, W)`` between adjacent windows. + offsets : Sequence of int or Sequence of (int, int) + Non-negative YX shifts in pixels. Plain ints are expanded to the outer + product over both axes; ``(dy, dx)`` pairs are used as given. A single + zero offset reduces to a plain tiled prediction. + blend : {"cosine", "uniform"} + Overlap weighting passed to :func:`_sliding_window_inference`. + + Returns + ------- + Tensor + Prediction with the same spatial shape as ``source``. + + Raises + ------ + ValueError + If ``offsets`` is empty, mixes scalars with pairs, contains a negative + value, or its largest shift is too big for reflect padding of this + input. + """ + if not len(offsets): + raise ValueError("offsets must contain at least one shift") + scalars = [isinstance(o, (int, np.integer)) for o in offsets] + if not all(scalars) and any(scalars): + raise ValueError(f"offsets must be all scalars or all (dy, dx) pairs, got {tuple(offsets)}") + if all(scalars): + shifts = list(itertools.product(offsets, offsets)) + else: + shifts = [tuple(o) for o in offsets] # type: ignore[misc] + if any(len(o) != 2 for o in shifts): + raise ValueError(f"paired offsets must each be (dy, dx), got {tuple(offsets)}") + flat = [c for pair in shifts for c in pair] + if min(flat) < 0: + raise ValueError(f"offsets must be non-negative, got {tuple(offsets)}") + margin = max(flat) + if margin == 0: + return _sliding_window_inference(forward_fn, source, patch_spatial, overlap_size, blend=blend) + + height, width = source.shape[-2], source.shape[-1] + # torch reflect padding requires pad < extent on every padded axis. + if margin >= min(height, width): + raise ValueError( + f"largest offset {margin} must be smaller than the input YX extent " + f"({height}, {width}) for reflect padding; use smaller offsets." + ) + # Reflect-pad by `margin` so every shifted grid still covers the whole FOV. + # Z is untouched: the window already spans the full Z extent it is given. + padded = F.pad(source, (margin, margin, margin, margin, 0, 0), mode="reflect") + + total: Tensor | None = None + output_dtype: torch.dtype | None = None + for offset_y, offset_x in shifts: + # `sub` starts at `offset` in padded coordinates, so the original FOV + # sits at `margin - offset` within it, and each window origin lands at + # a different phase relative to the specimen. + sub = padded[..., offset_y : offset_y + height + margin, offset_x : offset_x + width + margin] + out = _sliding_window_inference(forward_fn, sub, patch_spatial, overlap_size, blend=blend) + crop = out[ + ..., + margin - offset_y : margin - offset_y + height, + margin - offset_x : margin - offset_x + width, + ] + if total is None: + # `_sliding_window_inference` returns the model's dtype, so N + # half-precision crops overflow before the mean is taken. Sum in + # at least float32 (float64 stays float64) and cast back once. + output_dtype = crop.dtype + total = crop.to(torch.promote_types(crop.dtype, torch.float32)) + else: + total = total + crop + return (total / len(shifts)).to(output_dtype) + + class DynacellUNet(LightningModule): """Supervised regression U-Net for benchmark virtual staining. @@ -137,6 +578,21 @@ class DynacellUNet(LightningModule): example_input_yx_shape : Sequence[int] YX shape for example input (used by FNet3D for graph logging). Ignored when the model provides ``input_spatial_size``. + predict_blend : {"cosine", "uniform"} + How overlapping windows are combined when + ``predict_method='sliding_window'``. ``"cosine"`` (default) + cross-fades neighbours with a raised-cosine taper; ``"uniform"`` + takes a plain average and leaves visible seams where the number of + covering windows changes. See :func:`_sliding_window_inference`. + Has no effect when a single window covers the input. + predict_phase_shifts : Sequence[int] | Sequence[tuple[int, int]] | None + When set, average the prediction over these YX grid shifts to + suppress the decoder's checkerboard and (for ``UNetViT3D``) the ViT + token lattice; see :func:`_phase_shift_average` for which offsets + cancel which period and for the accuracy trade-off. + ``((0, 0), (5, 11), (11, 22), (22, 5))`` suppresses both at four + passes; a flat ``(0, 5, 11, 22)`` measures the same but costs the + outer product, sixteen. Off by default. ckpt_path : str | None Path to a checkpoint to load **weights only** at construction time. Intended for inference (predict/test), not training resumption — @@ -153,6 +609,40 @@ class DynacellUNet(LightningModule): the resume checkpoint, and the resume state overwrites it. The file at ``ckpt_path`` must therefore remain accessible for the lifetime of any run based on a pretrained leaf. + seg_aux : SegAuxDice or None + Auxiliary segmentation loss scored against the batch's ``fg_mask``. + When set, the training loss is ``loss_function(pred, target) + + seg_aux_weight * seg_aux(pred, target, fg_mask)``; ``loss_function`` + never sees the mask, and ``loss/validate`` stays the base term alone so + checkpoint selection means the same as for the baseline. Every batch + must then carry ``fg_mask`` (set ``fg_mask_key`` on the datamodule). + seg_aux_weight : float + Weight of the ``seg_aux`` term. Must be ``0.0`` when ``seg_aux`` is None. + seg_consistency : SegConsistencyLoss or None + Segmenter-consistency term on ``(pred, target)``, added as + ``seg_consistency_weight * seg_consistency(pred, target)`` on top of the + rest of the training loss. ``loss/validate`` stays without it; its value + is logged as ``loss/validate_segcons``. Needs no ``fg_mask``. + seg_consistency_weight : float or None + Weight of the ``seg_consistency`` term; required with it, ``None`` without it. + channels_last : bool, default False + Store the backbone's convolution weights in channels-last layout + (``torch.channels_last_3d`` for 5-D weights, ``torch.channels_last`` + for 4-D ones, since UNeXt2 mixes 2-D and 3-D layers) and feed 5-D + inputs as ``channels_last_3d``. Only strides change, so outputs and + state-dict keys and values match the default layout. Applied in + :meth:`configure_model`, before the strategy moves the module to the + device and wraps it in DDP; converting after the DDP wrap breaks its + gradient bucket views. Not saved in the hyperparameters, so a resumed + fit takes the value from its own config. + compile_model : bool, default False + During fit, run the backbone through ``torch.compile(self.model)`` + kept in a plain-dict cache, not as a registered submodule, so the + state-dict keys never change. Every other stage (validate, predict) + and any later use of the same module run the eager backbone: + sliding-window predict varies the input shape. Built in + :meth:`configure_model`, before the DDP wrap, and dropped when fit + ends or raises. Not saved in the hyperparameters. """ def __init__( @@ -169,11 +659,32 @@ def __init__( example_input_yx_shape: Sequence[int] = (256, 256), predict_method: Literal["full_image", "sliding_window"] = "full_image", predict_overlap: tuple[int, int, int] = (4, 256, 256), + predict_blend: Literal["cosine", "uniform"] = "cosine", + predict_phase_shifts: Sequence[int] | Sequence[tuple[int, int]] | None = None, ckpt_path: str | None = None, encoder_only: bool = False, + seg_aux: SegAuxDice | None = None, + seg_aux_weight: float = 0.0, + seg_consistency: SegConsistencyLoss | None = None, + seg_consistency_weight: float | None = None, + channels_last: bool = False, + compile_model: bool = False, ) -> None: super().__init__() - self.save_hyperparameters(ignore=["loss_function", "ckpt_path", "encoder_only"]) + # channels_last and compile_model change speed, not the model, so a + # resume takes them from its own config and older checkouts can still + # resume checkpoints written with them on. + self.save_hyperparameters( + ignore=[ + "loss_function", + "ckpt_path", + "encoder_only", + "seg_aux", + "seg_consistency", + "channels_last", + "compile_model", + ] + ) if model_config is None: model_config = {} net_class = _ARCHITECTURE.get(architecture) @@ -189,10 +700,23 @@ def __init__( self.log_samples_per_batch = log_samples_per_batch self.predict_method = predict_method self.predict_overlap = predict_overlap + self.predict_blend = predict_blend + self.predict_phase_shifts = predict_phase_shifts + self.seg_aux = seg_aux + self.seg_aux_weight = seg_aux_weight + _check_seg_consistency_args(seg_consistency, seg_consistency_weight, seg_aux) + self.seg_consistency = seg_consistency + self.seg_consistency_weight = seg_consistency_weight + self.channels_last = channels_last + self.compile_model = compile_model + # Fit-scoped compiled backbone; a plain dict keeps it out of the module tree. + self._compiled: dict[str, Callable[[Tensor], Tensor]] = {} self.training_step_outputs: list = [] # Each entry is a list of (loss, batch_size) tuples for weighted aggregation. self.validation_losses: list[list[tuple[Tensor, int]]] = [] + self.validation_dice_losses: list[list[tuple[Tensor, int]]] = [] + self.validation_segcons_losses: list[list[tuple[Tensor, int]]] = [] self.validation_step_outputs: list = [] # Cache fg_mask compatibility to avoid per-batch inspect.signature(). @@ -200,6 +724,8 @@ def __init__( self._loss_accepts_fg_mask = "fg_mask" in sig.parameters or any( p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values() ) + self._loss_returns_components = "return_components" in sig.parameters + _check_seg_aux_args(seg_aux, seg_aux_weight, self.loss_function, self._loss_accepts_fg_mask) # Build example_input_array for graph logging (TensorBoard/W&B). in_channels = model_config.get("in_channels") or 1 @@ -217,13 +743,41 @@ def __init__( raise ValueError("DynacellUNet(encoder_only=True) requires ckpt_path to be set") if not isinstance(self.model, FullyConvolutionalMAE): raise ValueError(f"encoder_only is only supported for architecture='fcmae', got {architecture!r}") - state_dict = torch.load(ckpt_path, weights_only=True, map_location="cpu")["state_dict"] + state_dict = _ckpt_state_dict(ckpt_path) prefix = "model.encoder." encoder_weights = {k.removeprefix(prefix): v for k, v in state_dict.items() if k.startswith(prefix)} self.model.encoder.load_state_dict(encoder_weights, strict=True) _logger.info(f"Loaded {len(encoder_weights)} encoder parameters from {ckpt_path}") elif ckpt_path is not None: - self.load_state_dict(torch.load(ckpt_path, weights_only=True, map_location="cpu")["state_dict"]) + self.load_state_dict(_ckpt_state_dict(ckpt_path)) + + def configure_model(self) -> None: + """Apply the opt-in ``channels_last`` and ``compile_model`` settings. + + Lightning calls this before the strategy moves the module to the device + and wraps it in DDP; both settings must precede the wrap. The hook may + run more than once, so both steps are idempotent. + """ + if self.channels_last: + for param in self.model.parameters(): + if param.ndim == 5: + param.data = param.data.contiguous(memory_format=torch.channels_last_3d) + elif param.ndim == 4: + param.data = param.data.contiguous(memory_format=torch.channels_last) + if self.compile_model and self.trainer.state.fn == TrainerFn.FITTING and "fit" not in self._compiled: + self._compiled["fit"] = torch.compile(self.model) + + def drop_compiled_model(self) -> None: + """Drop the fit-scoped compiled backbone, so later stages run the eager one.""" + self._compiled.clear() + + def configure_callbacks(self) -> list[Callback]: + """Attach the callback that drops the compiled backbone when a fit raises.""" + return [_DropCompiledModelOnException()] if self.compile_model else [] + + def on_fit_end(self) -> None: + """Drop the fit-scoped compiled backbone.""" + self.drop_compiled_model() def forward(self, x: Tensor) -> Tensor: """Run forward pass through the model. @@ -231,25 +785,60 @@ def forward(self, x: Tensor) -> Tensor: Parameters ---------- x : Tensor - Input tensor of shape ``(B, C, D, H, W)``. + Input tensor of shape ``(B, C, D, H, W)``. Made + ``channels_last_3d`` when ``channels_last`` is set. Returns ------- Tensor Model output. """ - return self.model(x) - - def _compute_loss(self, pred: Tensor, target: Tensor, batch: Sample) -> Tensor: - """Compute loss, optionally passing fg_mask to the loss function.""" - if "fg_mask" in batch: - if not self._loss_accepts_fg_mask: - raise TypeError( - f"{type(self.loss_function).__name__} does not accept 'fg_mask'. " - f"Use SpotlightLoss or remove fg_mask_key from the data config." - ) - return self.loss_function(pred, target, fg_mask=batch["fg_mask"]) - return self.loss_function(pred, target) + if self.channels_last and x.ndim == 5: + x = x.contiguous(memory_format=torch.channels_last_3d) + return self._compiled.get("fit", self.model)(x) + + def _compute_loss(self, pred: Tensor, target: Tensor, batch: Sample) -> tuple[Tensor, dict[str, Tensor]]: + """Compute loss, optionally passing fg_mask to the loss function. + + Returns the components alongside the scalar so the Spotlight terms can + be logged separately. They come from the loss itself rather than being + re-derived here: a second derivation would silently fork from the + objective actually being optimized, which is the one thing that makes + the logged numbers worthless for calibration. + + Returns + ------- + tuple of (Tensor, dict of str to Tensor) + Scalar loss and its components (empty for a plain criterion). + """ + if "fg_mask" not in batch: + return self.loss_function(pred, target), {} + if not self._loss_accepts_fg_mask: + raise TypeError( + f"{type(self.loss_function).__name__} does not accept 'fg_mask'. " + f"Use SpotlightLoss or remove fg_mask_key from the data config." + ) + # Re-binarize: hcs.py patches fg_mask into gpu_augmentations, and the + # affine resamples it with bilinear interpolation, so the mask arrives + # with fractional values on any arm whose augmentation stack resamples. + # Flip-only stacks are unaffected; this keeps the two cases identical. + fg_mask = (batch["fg_mask"] > 0.5).float() + if not self._loss_returns_components: + return self.loss_function(pred, target, fg_mask=fg_mask), {} + return self.loss_function(pred, target, fg_mask=fg_mask, return_components=True) + + def _compute_seg_aux_loss(self, pred: Tensor, target: Tensor, batch: Sample) -> tuple[Tensor, Tensor, Tensor]: + """Compute the mask-free base loss and the unweighted ``seg_aux`` Dice. + + Returns + ------- + tuple of (Tensor, Tensor, Tensor) + Base loss, Dice loss, and the number of (sample, channel) patches + that contributed to the Dice. + """ + base = self.loss_function(pred, target) + dice, comps = self.seg_aux(pred, target, _require_fg_mask(batch), return_components=True) + return base, dice, comps["n_valid"] def training_step(self, batch: Sample, batch_idx: int) -> Tensor: """Execute a single training step. @@ -269,7 +858,16 @@ def training_step(self, batch: Sample, batch_idx: int) -> Tensor: source = batch["source"] target = batch["target"] pred = self.forward(source) - loss = self._compute_loss(pred, target, batch) + if self.seg_aux is None: + loss, components = self._compute_loss(pred, target, batch) + else: + base, dice, n_valid = self._compute_seg_aux_loss(pred, target, batch) + loss = base + self.seg_aux_weight * dice + components = {"base": base, "dice": dice, "dice_n_valid": n_valid} + if self.seg_consistency is not None: + segcons, segcons_components = self.seg_consistency(pred, target, return_components=True) + components = {"base": loss, **components, **segcons_components} + loss = loss + self.seg_consistency_weight * segcons if batch_idx < self.log_batches_per_epoch: self.training_step_outputs.extend(detach_sample((source, target, pred), self.log_samples_per_batch)) self.log( @@ -282,6 +880,21 @@ def training_step(self, batch: Sample, batch_idx: int) -> Tensor: sync_dist=True, batch_size=source.shape[0], ) + # Unweighted Spotlight terms, mirroring `loss/g_recon_*_train` on the GAN + # path. Without these the fused scalar cannot say whether the Dice term + # is contributing anything, which is what the lambda_mse choice rests on. + # With seg_aux: the base term, the unweighted Dice, and its valid-patch count. + # With seg_consistency: the loss without it, and its unweighted flow/probability terms. + for name, value in components.items(): + self.log( + f"loss/{name}_train", + value, + on_step=True, + on_epoch=True, + logger=True, + sync_dist=True, + batch_size=source.shape[0], + ) return loss def validation_step(self, batch: Sample, batch_idx: int, dataloader_idx: int = 0): @@ -299,10 +912,17 @@ def validation_step(self, batch: Sample, batch_idx: int, dataloader_idx: int = 0 source: Tensor = batch["source"] target: Tensor = batch["target"] pred = self.forward(source) - loss = self._compute_loss(pred, target, batch) - if dataloader_idx + 1 > len(self.validation_losses): - self.validation_losses.append([]) - self.validation_losses[dataloader_idx].append((loss.detach(), source.shape[0])) + if self.seg_aux is None: + loss, _ = self._compute_loss(pred, target, batch) + else: + # loss/validate stays the base term so the checkpoint monitor means + # the same as the baseline's; the Dice goes to loss/validate_dice. + loss, dice, _ = self._compute_seg_aux_loss(pred, target, batch) + _record_val_loss(self.validation_dice_losses, dataloader_idx, dice.detach(), source.shape[0]) + if self.seg_consistency is not None: + segcons = self.seg_consistency(pred, target) + _record_val_loss(self.validation_segcons_losses, dataloader_idx, segcons.detach(), source.shape[0]) + _record_val_loss(self.validation_losses, dataloader_idx, loss.detach(), source.shape[0]) self.log( f"loss/val/{dataloader_idx}", loss, @@ -360,8 +980,16 @@ def on_validation_epoch_end(self): _log_samples(self, "val_samples", self.validation_step_outputs) if self.validation_losses: self.log("loss/validate", _aggregate_validation_losses(self.validation_losses), sync_dist=True) + if self.validation_dice_losses: + self.log("loss/validate_dice", _aggregate_validation_losses(self.validation_dice_losses), sync_dist=True) + if self.validation_segcons_losses: + self.log( + "loss/validate_segcons", _aggregate_validation_losses(self.validation_segcons_losses), sync_dist=True + ) self.validation_step_outputs.clear() self.validation_losses.clear() + self.validation_dice_losses.clear() + self.validation_segcons_losses.clear() def configure_optimizers(self): """Configure AdamW optimizer with LR scheduler.""" @@ -377,7 +1005,8 @@ def configure_optimizers(self): def predict_sliding_window(self, source: Tensor, overlap_size: tuple[int, int, int] = (4, 256, 256)) -> Tensor: """Run sliding-window inference over a large input volume. - Overlapping regions are averaged across all covering patches. + Overlapping regions are combined with the cosine cross-fade described + in :func:`_sliding_window_inference`, per ``self.predict_blend``. Parameters ---------- @@ -391,55 +1020,47 @@ def predict_sliding_window(self, source: Tensor, overlap_size: tuple[int, int, i Tensor Prediction with the same spatial shape as ``source``. """ - spatial = source.shape[-3:] - patch_spatial = tuple(self.model.input_spatial_size) - n_spatial = 3 - overlap = tuple(overlap_size) - - for i in range(n_spatial): - S, P, ov = spatial[i], patch_spatial[i], overlap[i] - if S < P: - raise ValueError(f"spatial dim {i} size {S} must be >= patch size {P}") - if not (0 <= ov < P): - raise ValueError(f"overlap at dim {i} must satisfy 0 <= overlap < patch (got {ov} vs {P})") - - # Accumulators are allocated lazily from the first patch output so - # their channel dimension matches the model's out_channels (which can - # differ from source's in_channels, e.g. 1 phase in -> 2 target out). - prediction_sum: Tensor | None = None - prediction_count: Tensor | None = None - - start_lists = [] - for i in range(n_spatial): - S, P, ov = spatial[i], patch_spatial[i], overlap[i] - stride = P - ov - last = S - P - starts = [0] - while starts[-1] + stride < last: - starts.append(starts[-1] + stride) - if starts[-1] != last: - starts.append(last) - start_lists.append(starts) + if self.predict_phase_shifts: + return _phase_shift_average( + self.forward, + source, + tuple(self.model.input_spatial_size), + overlap_size, + self.predict_phase_shifts, + blend=self.predict_blend, + ) + return _sliding_window_inference( + self.forward, + source, + tuple(self.model.input_spatial_size), + overlap_size, + blend=self.predict_blend, + ) - with torch.no_grad(): - for starts in itertools.product(*start_lists): - slicer: list = [slice(None)] * source.ndim - for i, st in enumerate(starts): - slicer[-(n_spatial - i)] = slice(st, st + patch_spatial[i]) - patch_out = self.forward(source[tuple(slicer)]) - if prediction_sum is None: - out_shape = list(source.shape) - out_shape[1] = patch_out.shape[1] - prediction_sum = torch.zeros(out_shape, device=source.device, dtype=patch_out.dtype) - prediction_count = torch.zeros(out_shape, device=source.device, dtype=patch_out.dtype) - prediction_sum[tuple(slicer)] += patch_out - prediction_count[tuple(slicer)] += 1 - - if prediction_sum is None: - raise RuntimeError("sliding window produced no patches") - if not torch.all(prediction_count > 0): - raise RuntimeError("sliding window left uncovered voxels") - return prediction_sum / prediction_count + +class _DropCompiledModelOnException(Callback): + """Drop :class:`DynacellUNet`'s fit-scoped compiled backbone when a Trainer run raises. + + Lightning skips ``on_fit_end`` on an exception, so without this a later stage + on the same module would still run the compiled callable. + """ + + def on_exception(self, trainer, pl_module: LightningModule, exception: BaseException) -> None: + """Drop the compiled backbone.""" + pl_module.drop_compiled_model() + + +class _DropCompiledNetOnException(Callback): + """Free :class:`DynacellFlowMatching`'s compiled inference copy when a Trainer run raises. + + Lightning skips ``on_predict_end`` on an exception and runs only callback ``on_exception`` + hooks, so without this the copy, which is not a registered submodule, keeps its device memory + until the next predict run. + """ + + def on_exception(self, trainer, pl_module: LightningModule, exception: BaseException) -> None: + """Drop the compiled copy.""" + pl_module.model.drop_compiled_net() class DynacellFlowMatching(LightningModule): @@ -467,10 +1088,11 @@ class DynacellFlowMatching(LightningModule): log_samples_per_batch : int Number of samples per batch to log. num_generate_steps : int - Number of ODE steps for prediction inference. + Number of ODE time points for prediction inference; a fixed-grid + ``predict_sampling_method`` takes ``num_generate_steps - 1`` steps. num_log_steps : int - Number of ODE steps for validation image generation (cheaper than - ``num_generate_steps``). + Number of ODE time points for validation image generation (cheaper + than ``num_generate_steps``). compute_validation_loss : bool Whether to compute and log flow-matching validation loss on the validation loader. Disabled by default to preserve the previous @@ -488,6 +1110,23 @@ class DynacellFlowMatching(LightningModule): Overlap for ``denoise`` and ``iterative``. Ignored by ``sliding_window``; must be ``0`` or ``[0, 0, 0]`` when ``predict_method='sliding_window'``. + predict_sampling_method : str + ``torchdiffeq`` ODE method for ``generate``, ``sliding_window`` and + ``iterative``: adaptive ``"dopri5"`` (default), or a fixed-grid method + (``"euler"``, ``"midpoint"``, ``"heun2"``, ``"rk4"``) that takes + ``num_generate_steps - 1`` steps. + predict_time_schedule : {"uniform", "cosine"} or tuple of float + Spacing of the ``num_generate_steps`` ODE time points; ``"cosine"`` + packs a fixed-grid solver's steps toward both ends of the interval, + where adaptive dopri5 spends most of its evaluations, and ``(p, q)`` + takes the Beta(p, q) quantiles of a uniform grid (cosine is + Beta(0.5, 0.5); ``p < q`` packs more of them toward the noise end). + predict_compile : bool + ``torch.compile`` the velocity network for the ``generate``, + ``sliding_window`` and ``iterative`` predict methods (``denoise`` calls + the network directly). Only :meth:`predict_step` samples through the + compiled copy, which every predict run rebuilds from the current + weights; validation sampling always uses the live network. ckpt_path : str | None Path to a checkpoint to load **weights only** at construction time. Intended for inference (predict/test), not training resumption — @@ -495,6 +1134,56 @@ class DynacellFlowMatching(LightningModule): restored. Bypasses LightningCLI's checkpoint hparam merging, so predict-time settings (``predict_method``, ``predict_overlap``, etc.) are taken from the config rather than the checkpoint. + seg_aux : SegAuxDice or None + Auxiliary segmentation loss on the one-step data estimate + ``x1_hat = x_t + (1 - t) * v_hat``, scored against the batch's + ``fg_mask`` and gated to ``t >= 1 - seg_aux_t0`` (see + :class:`~dynacell.celldiff_wrapper.CELLDiff3DVS`). The training loss + becomes ``velocity_mse + seg_aux_weight * dice``; ``loss/validate`` + stays velocity-only and, with ``compute_validation_loss``, the Dice is + logged as ``loss/validate_dice``. Every batch whose loss is computed + must carry ``fg_mask``. Prediction and generation are unaffected. + seg_aux_weight : float + Weight of the ``seg_aux`` term. Must be ``0.0`` when ``seg_aux`` is None. + seg_aux_t0 : float + Fraction of the time range, nearest the data end, in which ``seg_aux`` + applies; it gates the C-joint mask Dice the same way. + mask_mode : {"joint", "cond"} or None + Segmentation inside the generative process (Spotlight v2 Stage 1b); + ``None`` is the baseline. Both variants take the mask from the batch's + ``fg_mask`` (binarized at 0.5) during fit, encoded ``{0, 1} -> {-1, 1}`` + like the ``MinMaxSampled`` target. ``"joint"`` (C-joint): the flow + generates ``[image, mask]`` (``net_config.in_channels`` = 2 x target + channels); the loss is ``velocity_image + mask_velocity_weight * + velocity_mask + mask_dice_weight * dice``; ``loss/validate`` is + ``velocity_image`` alone, and prediction returns only the image half. + ``"cond"`` (C-cond): the mask is a conditioning channel after phase + (``net_config.cond_channels`` = 2): ``fg_mask`` corrupted by + ``mask_corruption`` in training, clean ``fg_mask`` in validation, and + ``cond_mask_source`` in prediction. + mask_velocity_weight : float + C-joint weight of the mask-channel velocity loss. + mask_dice_weight : float + C-joint weight of the gated soft Dice on the mask channel's one-step + estimate (see :meth:`~dynacell.celldiff_wrapper.CELLDiff3DVS.joint_mask_losses`). + mask_corruption : MaskCorruption or None + C-cond training-only mask corruption; ``None`` trains on the clean mask. + cond_mask_source : CondMaskSource or None + C-cond predict-time mask source; required to predict with + ``mask_mode="cond"``. + target_bg_lowpass : BackgroundLowPass or None + Training-only target transform (Spotlight v2 Track H): the training + step replaces ``target`` by ``target_bg_lowpass(target, fg_mask)``, + which keeps the target inside the dilated, feathered foreground and + replaces the background by a smooth (or flat) estimate from background + pixels only, so the flow is not asked to generate background noise or + illumination that phase cannot predict. The background stays + supervised, toward that estimate. It runs after normalization and + the GPU augmentations; every training-loss term (``seg_aux``, C-joint, + C-cond) and the logged training samples see the transformed target. + Validation, its logged samples and prediction see the raw target, so + ``loss/validate`` keeps the baseline's criterion. Every training batch + must carry ``fg_mask``. """ def __init__( @@ -512,14 +1201,58 @@ def __init__( compute_validation_loss: bool = False, predict_method: Literal["denoise", "generate", "sliding_window", "iterative"] = "generate", predict_overlap: int | tuple[int, int, int] = 256, + predict_sampling_method: str = "dopri5", + predict_time_schedule: Literal["uniform", "cosine"] | tuple[float, float] = "uniform", + predict_compile: bool = False, ckpt_path: str | None = None, + seg_aux: SegAuxDice | None = None, + seg_aux_weight: float = 0.0, + seg_aux_t0: float = 0.7, + mask_mode: Literal["joint", "cond"] | None = None, + mask_velocity_weight: float = 1.0, + mask_dice_weight: float = 0.0, + mask_corruption: MaskCorruption | None = None, + cond_mask_source: CondMaskSource | None = None, + target_bg_lowpass: BackgroundLowPass | None = None, ) -> None: super().__init__() self.save_hyperparameters( - ignore=["predict_method", "predict_overlap", "num_generate_steps", "num_log_steps", "ckpt_path"] + ignore=[ + "predict_method", + "predict_overlap", + "predict_sampling_method", + "predict_time_schedule", + "predict_compile", + "num_generate_steps", + "num_log_steps", + "ckpt_path", + "seg_aux", + "mask_corruption", + "cond_mask_source", + "target_bg_lowpass", + ] + ) + if seg_aux is None and seg_aux_weight != 0.0: + raise ValueError(f"seg_aux_weight={seg_aux_weight} has no effect without seg_aux.") + net_kwargs = net_config or {} + _check_mask_mode_args( + mask_mode, net_kwargs, seg_aux, mask_velocity_weight, mask_dice_weight, mask_corruption, cond_mask_source + ) + net = CELLDiffNet(**net_kwargs) + self.model = CELLDiff3DVS( + net, + **(transport_config or {}), + seg_aux=seg_aux, + seg_aux_t0=seg_aux_t0, + joint_mask=mask_mode == "joint", ) - net = CELLDiffNet(**(net_config or {})) - self.model = CELLDiff3DVS(net, **(transport_config or {})) + self.seg_aux_weight = seg_aux_weight + self.mask_mode = mask_mode + self.mask_velocity_weight = mask_velocity_weight + self.mask_dice_weight = mask_dice_weight + self.mask_corruption = mask_corruption + self.cond_mask_source = cond_mask_source + self.target_bg_lowpass = target_bg_lowpass self.lr = lr self.schedule = schedule self.warmup_steps = warmup_steps @@ -531,11 +1264,16 @@ def __init__( self.compute_validation_loss = compute_validation_loss self.predict_method = predict_method self.predict_overlap = predict_overlap + self.predict_sampling_method = predict_sampling_method + self.predict_time_schedule = predict_time_schedule + self.predict_compile = predict_compile self._training_step_outputs: list = [] self._validation_losses: list[list[tuple[Tensor, int]]] = [] + self._validation_dice_losses: list[list[tuple[Tensor, int]]] = [] + self._validation_mask_velocity_losses: list[list[tuple[Tensor, int]]] = [] self._val_log_batch: tuple[Tensor, Tensor] | None = None if ckpt_path is not None: - self.load_state_dict(torch.load(ckpt_path, weights_only=True, map_location="cpu")["state_dict"]) + self.load_state_dict(_ckpt_state_dict(ckpt_path)) def training_step(self, batch: dict, batch_idx: int) -> Tensor: """Compute flow-matching training loss for one batch. @@ -553,8 +1291,11 @@ def training_step(self, batch: dict, batch_idx: int) -> Tensor: Scalar flow-matching loss. """ phase: Tensor = batch["source"] + if self.target_bg_lowpass is not None: + with torch.no_grad(): + batch = {**batch, "target": self.target_bg_lowpass(batch["target"], _require_fg_mask(batch))} target: Tensor = batch["target"] - loss = self.model(phase, target) + loss, _, components = self._flow_losses(batch, corrupt=True) self.log( "loss/train", loss, @@ -565,26 +1306,95 @@ def training_step(self, batch: dict, batch_idx: int) -> Tensor: sync_dist=True, batch_size=phase.shape[0], ) + for name, value in components.items(): + self.log( + f"loss/{name}_train", + value, + on_step=True, + on_epoch=True, + logger=True, + sync_dist=True, + batch_size=phase.shape[0], + ) if batch_idx < self.log_batches_per_epoch: self._training_step_outputs.extend(detach_sample((phase, target), self.log_samples_per_batch)) return loss + def _conditioning(self, batch: dict, corrupt: bool) -> Tensor: + """Return the network conditioning: phase, plus the encoded mask for C-cond. + + ``corrupt`` applies ``mask_corruption``; only the training step sets it. + """ + phase: Tensor = batch["source"] + if self.mask_mode != "cond": + return phase + mask = binarize_mask(_require_fg_mask(batch)) + if corrupt and self.mask_corruption is not None: + mask = self.mask_corruption(mask) + return torch.cat([phase, encode_mask(mask).to(phase.dtype)], dim=1) + + def _flow_losses(self, batch: dict, corrupt: bool) -> tuple[Tensor, Tensor, dict[str, Tensor]]: + """Compute the training objective, its baseline-comparable part, and components. + + Returns + ------- + tuple of (Tensor, Tensor, dict of str to Tensor) + The weighted objective; the image velocity loss that + ``loss/validate`` reports (the whole objective for the baseline); + and the unweighted terms to log (empty for the baseline). + """ + target: Tensor = batch["target"] + if self.mask_mode == "joint": + out = self.model.joint_mask_losses(batch["source"], target, _require_fg_mask(batch)) + base = out["velocity_image"] + loss = base + self.mask_velocity_weight * out["velocity_mask"] + self.mask_dice_weight * out["dice"] + components = { + "base": base, + "mask_velocity": out["velocity_mask"], + "dice": out["dice"], + "dice_n_valid": out["n_valid"], + "dice_n_gated": out["n_gated"], + } + return loss, base, components + cond = self._conditioning(batch, corrupt) + if self.model.seg_aux is None: + loss = self.model(cond, target) + return loss, loss, {} + base, aux = self.model(cond, target, _require_fg_mask(batch)) + components = { + "base": base, + "dice": aux["dice"], + "dice_n_valid": aux["n_valid"], + "dice_n_gated": aux["n_gated"], + } + return base + self.seg_aux_weight * aux["dice"], base, components + def validation_step(self, batch: dict, batch_idx: int, dataloader_idx: int = 0) -> None: - """Capture validation samples and optionally compute loss.""" + """Capture validation samples and optionally compute loss. + + C-cond conditions on the uncorrupted ``fg_mask`` here. + """ if batch_idx == 0 and self._val_log_batch is None: n = self.log_samples_per_batch self._val_log_batch = ( - batch["source"][:n].clone(), + self._conditioning(batch, corrupt=False)[:n].clone(), batch["target"][:n].clone(), ) if not self.compute_validation_loss: return phase: Tensor = batch["source"] - target: Tensor = batch["target"] - loss = self.model(phase, target) - if dataloader_idx + 1 > len(self._validation_losses): - self._validation_losses.append([]) - self._validation_losses[dataloader_idx].append((loss.detach(), phase.shape[0])) + # loss/validate stays the image velocity loss; aux terms are logged apart. + _, loss, components = self._flow_losses(batch, corrupt=False) + if "dice" in components: + _record_val_loss(self._validation_dice_losses, dataloader_idx, components["dice"].detach(), phase.shape[0]) + if "mask_velocity" in components: + _record_val_loss( + self._validation_mask_velocity_losses, + dataloader_idx, + components["mask_velocity"].detach(), + phase.shape[0], + ) + _record_val_loss(self._validation_losses, dataloader_idx, loss.detach(), phase.shape[0]) self.log( f"loss/val/{dataloader_idx}", loss, @@ -610,13 +1420,40 @@ def on_validation_epoch_end(self) -> None: self._val_log_batch = None if self._validation_losses: self.log("loss/validate", _aggregate_validation_losses(self._validation_losses), sync_dist=True) + if self._validation_dice_losses: + self.log("loss/validate_dice", _aggregate_validation_losses(self._validation_dice_losses), sync_dist=True) + if self._validation_mask_velocity_losses: + self.log( + "loss/validate_mask_velocity", + _aggregate_validation_losses(self._validation_mask_velocity_losses), + sync_dist=True, + ) self._validation_losses.clear() + self._validation_dice_losses.clear() + self._validation_mask_velocity_losses.clear() + + def configure_callbacks(self) -> Callback: + """Attach the callback that frees the compiled inference copy when a run raises.""" + return _DropCompiledNetOnException() + + def on_predict_start(self) -> None: + """Drop any compiled copy left behind, so this run builds its own from the current weights. + + The copy also follows the current device and autocast state. + """ + self.model.drop_compiled_net() + + def on_predict_end(self) -> None: + """Free the compiled copy's memory.""" + self.model.drop_compiled_net() def predict_step(self, batch: dict, batch_idx: int, dataloader_idx: int = 0) -> Tensor: """Generate virtual staining for one batch via ODE sampling. Pads source if smaller than ``input_spatial_size``, dispatches to the configured predict method, then crops back to the original shape. + C-cond appends the encoded ``cond_mask_source`` mask to the source; + C-joint returns only the image half of the generated channels. Parameters ---------- @@ -634,6 +1471,11 @@ def predict_step(self, batch: dict, batch_idx: int, dataloader_idx: int = 0) -> """ source: Tensor = batch["source"] original_shape = source.shape[2:] + if self.mask_mode == "cond": + if self.cond_mask_source is None: + raise ValueError("mask_mode='cond' needs cond_mask_source to predict.") + mask = self.cond_mask_source.read(batch["index"], tuple(original_shape)).to(source) + source = torch.cat([source, encode_mask(mask)], dim=1) # Pad source if any spatial dim is smaller than input_spatial_size. patch_size = self.model.net.input_spatial_size @@ -647,7 +1489,13 @@ def predict_step(self, batch: dict, batch_idx: int, dataloader_idx: int = 0) -> if self.predict_method == "denoise": prediction = self.model.denoise_sliding_window(source, overlap_size=self.predict_overlap) elif self.predict_method == "generate": - prediction = self.model.generate(source, num_steps=self.num_generate_steps) + prediction = self.model.generate( + source, + num_steps=self.num_generate_steps, + sampling_method=self.predict_sampling_method, + time_schedule=self.predict_time_schedule, + compiled=self.predict_compile, + ) elif self.predict_method == "sliding_window": # generate_sliding_window partitions into non-overlapping tiles # and does NOT consume predict_overlap. A non-zero overlap means @@ -662,12 +1510,21 @@ def predict_step(self, batch: dict, batch_idx: int, dataloader_idx: int = 0) -> "Use predict_method='iterative' for overlap-anchored tiled inference, " "or set predict_overlap=[0, 0, 0] to acknowledge the non-overlapping behavior." ) - prediction = self.model.generate_sliding_window(source, num_steps=self.num_generate_steps) + prediction = self.model.generate_sliding_window( + source, + num_steps=self.num_generate_steps, + sampling_method=self.predict_sampling_method, + time_schedule=self.predict_time_schedule, + compiled=self.predict_compile, + ) elif self.predict_method == "iterative": prediction = self.model.generate_iterative( source, num_steps=self.num_generate_steps, overlap_size=self.predict_overlap, + sampling_method=self.predict_sampling_method, + time_schedule=self.predict_time_schedule, + compiled=self.predict_compile, ) else: raise ValueError( @@ -675,6 +1532,8 @@ def predict_step(self, batch: dict, batch_idx: int, dataloader_idx: int = 0) -> "Choose 'denoise', 'generate', 'sliding_window', or 'iterative'." ) + if self.mask_mode == "joint": + prediction = prediction[:, : self.model.net.inconv.in_channels // 2] return prediction[:, :, : original_shape[0], : original_shape[1], : original_shape[2]] def configure_optimizers(self): @@ -723,7 +1582,16 @@ class DynacellGAN(LightningModule): discriminator_config : dict or None Keyword arguments forwarded to :class:`MultiScalePatchGAN3D`. lambda_l1 : float - Weight of the L1 reconstruction loss in the generator objective. + Weight of the reconstruction loss in the generator objective. Named for + the L1 default; it weights whatever ``recon_loss`` is. + recon_loss : nn.Module or None + Generator reconstruction criterion. ``None`` (default) uses + :class:`torch.nn.L1Loss`, which is what every published pix2pix family + trained with. A loss accepting ``fg_mask`` (e.g. + :class:`viscy_utils.losses.SpotlightLoss`) receives the batch's + foreground mask. Note ``lambda_l1`` was tuned against L1's magnitude, so + a swapped loss on a different scale re-balances the generator objective + against the adversarial term — watch ``loss/g_recon_*_train``. loss_type : {"lsgan", "nonsat", "rpgan"} Adversarial loss family. Default ``"lsgan"`` matches the pre-modernization recipe. ``"nonsat"`` is the StyleGAN2 default; @@ -775,10 +1643,31 @@ class DynacellGAN(LightningModule): example_input_yx_shape : Sequence of int YX shape used to build ``example_input_array`` for graph logging when the generator does not advertise an ``input_spatial_size``. - predict_method : {"full_image"} - Prediction method. Only ``"full_image"`` is supported. + predict_method : {"full_image", "sliding_window"} + Prediction method. ``"full_image"`` runs the generator on the whole + input (requires the input to match the generator's ``input_spatial_size``). + ``"sliding_window"`` tiles inputs larger than ``input_spatial_size`` into + overlapping windows and averages them — needed for the fixed-size ViT + generator on test volumes larger than its trained crop (e.g. the + 640x960 A549 test set vs the 512x512 training crop). predict_overlap : tuple of int - Reserved for future tiled inference; currently unused at predict. + Overlap in ``(D, H, W)`` between adjacent windows when + ``predict_method='sliding_window'``; ignored for ``'full_image'``. + predict_blend : {"cosine", "uniform"} + How overlapping windows are combined when + ``predict_method='sliding_window'``. ``"cosine"`` (default) + cross-fades neighbours with a raised-cosine taper; ``"uniform"`` + takes a plain average and leaves visible seams where the number of + covering windows changes. See :func:`_sliding_window_inference`. + Has no effect when a single window covers the input. + predict_phase_shifts : Sequence of int or Sequence of (int, int) or None + When set, average the prediction over these YX grid shifts to + suppress the decoder's checkerboard and the ViT token lattice; see + :func:`_phase_shift_average` for which offsets cancel which period + and for the accuracy trade-off. + ``((0, 0), (5, 11), (11, 22), (22, 5))`` suppresses both at four + passes; a flat ``(0, 5, 11, 22)`` measures the same but costs the + outer product, sixteen. Off by default. ckpt_path : str or None Optional path to a Lightning checkpoint to load weights from at construction time. Loaded with ``strict=False`` so pre-modernization @@ -789,6 +1678,23 @@ class DynacellGAN(LightningModule): keys but EMA is enabled, the EMA submodule is seeded from the loaded generator weights (so inference matches the non-EMA inference path on legacy checkpoints). + seg_aux : SegAuxDice or None + Auxiliary segmentation loss on the generator output, scored against + the batch's ``fg_mask``. Adds ``seg_aux_weight * dice`` to the + generator objective as its own term (not scaled by ``lambda_l1``); + ``recon_loss`` is then called without the mask, and + ``loss/validate`` / ``loss/validate_ema`` stay reconstruction-only. + Every batch must carry ``fg_mask``. + seg_aux_weight : float + Weight of the ``seg_aux`` term. Must be ``0.0`` when ``seg_aux`` is None. + seg_consistency : SegConsistencyLoss or None + Segmenter-consistency term on the generator output, added to the + generator objective as ``seg_consistency_weight * seg_consistency(pred, + target)`` (not scaled by ``lambda_l1``). ``loss/validate`` / + ``loss/validate_ema`` stay reconstruction-only; its value is logged as + ``loss/validate_segcons`` / ``loss/validate_ema_segcons``. + seg_consistency_weight : float or None + Weight of the ``seg_consistency`` term; required with it, ``None`` without it. """ def __init__( @@ -797,6 +1703,7 @@ def __init__( generator_config: dict | None = None, discriminator_config: dict | None = None, lambda_l1: float = 100.0, + recon_loss: nn.Module | None = None, loss_type: Literal["lsgan", "nonsat", "rpgan"] = "lsgan", lambda_adv: float = 1.0, r1_gamma: float = 0.0, @@ -814,15 +1721,27 @@ def __init__( log_batches_per_epoch: int = 8, log_samples_per_batch: int = 1, example_input_yx_shape: Sequence[int] = (512, 512), - predict_method: Literal["full_image"] = "full_image", + predict_method: Literal["full_image", "sliding_window"] = "full_image", predict_overlap: tuple[int, int, int] = (4, 256, 256), + predict_blend: Literal["cosine", "uniform"] = "cosine", + predict_phase_shifts: Sequence[int] | Sequence[tuple[int, int]] | None = None, ckpt_path: str | None = None, + seg_aux: SegAuxDice | None = None, + seg_aux_weight: float = 0.0, + seg_consistency: SegConsistencyLoss | None = None, + seg_consistency_weight: float | None = None, ) -> None: super().__init__() # Lightning's manual-optimization API: required because the GAN # alternates two optimizers per training_step. self.automatic_optimization = False - self.save_hyperparameters(ignore=["ckpt_path"]) + # recon_loss is ignored for the same reason loss_function is on DynacellUNet: + # an nn.Module in hparams gets pickled into the checkpoint, and + # VisCyCLI._parse_ckpt_path lets checkpoint hparams win on non-fit + # subcommands for any key the predict leaf does not declare. A single + # pickled class also makes torch.load(weights_only=True) — which + # _ckpt_state_dict uses — raise for the whole file. + self.save_hyperparameters(ignore=["ckpt_path", "recon_loss", "seg_aux", "seg_consistency"]) net_class = _ARCHITECTURE.get(architecture) if net_class is None: @@ -847,6 +1766,23 @@ def __init__( self.generator = net_class(**(generator_config or {})) self.discriminator = MultiScalePatchGAN3D(**(discriminator_config or {})) + # Generator reconstruction term. Default keeps the published behaviour + # (plain L1 under lambda_l1); SpotlightLoss swaps in under the same weight. + self.recon_loss = recon_loss if recon_loss is not None else nn.L1Loss() + # Cache fg_mask compatibility to avoid per-batch inspect.signature(), + # mirroring DynacellUNet. + _recon_sig = inspect.signature(self.recon_loss.forward) + self._recon_accepts_fg_mask = "fg_mask" in _recon_sig.parameters or any( + p.kind == inspect.Parameter.VAR_KEYWORD for p in _recon_sig.parameters.values() + ) + self._recon_returns_components = "return_components" in _recon_sig.parameters + _check_seg_aux_args(seg_aux, seg_aux_weight, self.recon_loss, self._recon_accepts_fg_mask) + self.seg_aux = seg_aux + self.seg_aux_weight = seg_aux_weight + _check_seg_consistency_args(seg_consistency, seg_consistency_weight, seg_aux) + self.seg_consistency = seg_consistency + self.seg_consistency_weight = seg_consistency_weight + self.lambda_l1 = lambda_l1 self.loss_type = loss_type self.lambda_adv = lambda_adv @@ -866,6 +1802,8 @@ def __init__( self.log_samples_per_batch = log_samples_per_batch self.predict_method = predict_method self.predict_overlap = predict_overlap + self.predict_blend = predict_blend + self.predict_phase_shifts = predict_phase_shifts # D-step counter for lazy R1 schedule. self.global_step would # advance by 2 per training_step (D opt + G opt) so it can't be used @@ -894,6 +1832,10 @@ def __init__( # The second one is only populated when generator_ema exists. self.validation_losses_raw: list[list[tuple[Tensor, int]]] = [] self.validation_losses_ema: list[list[tuple[Tensor, int]]] = [] + self.validation_dice_raw: list[list[tuple[Tensor, int]]] = [] + self.validation_dice_ema: list[list[tuple[Tensor, int]]] = [] + self.validation_segcons_raw: list[list[tuple[Tensor, int]]] = [] + self.validation_segcons_ema: list[list[tuple[Tensor, int]]] = [] self.validation_step_outputs: list = [] # Build example_input_array for graph logging (TensorBoard/W&B). @@ -907,7 +1849,40 @@ def __init__( self.example_input_array = torch.rand(1, in_channels, d, h, w) if ckpt_path is not None: - state = torch.load(ckpt_path, weights_only=True, map_location="cpu")["state_dict"] + state = _ckpt_state_dict(ckpt_path) + # A checkpoint carrying an EMA shadow that this instance did not build + # must not lose it. EMA construction above is gated on ``ema_kimg``, a + # *training* hyperparameter a predict config has no reason to carry, so + # a predict run that omitted it silently discarded every + # generator_ema.* tensor under strict=False and fell through to the raw + # generator in ``_inference_generator``. That is exactly what happened + # to the pix2pix3d benchmark: checkpoints were selected on + # ``loss/validate_ema`` (the ModelCheckpoint monitor in the + # train_4gpu_modernized leaves) and then evaluated with the non-EMA + # weights, with only a warning in the job's stderr to say so. + # + # Build the shadow from the checkpoint's own keys, before the load, so + # the EMA tensors land in it on the single pass. At inference only the + # shadow's *existence* matters; requiring every predict config to + # restate a decay constant the checkpoint already records is what made + # the silent drop possible. + # + # Deliberately NOT adopted from the checkpoint: ``use_ema_at_predict``. + # Which generator runs stays an explicit config decision — inferring it + # here would flip every existing predict arm on its next run, the same + # class of silent change this guard exists to end. + ema_keys_in_ckpt = sum(1 for k in state if k.startswith("generator_ema.")) + if ema_keys_in_ckpt and self.generator_ema is None: + self.generator_ema = copy.deepcopy(self.generator) + self.generator_ema.requires_grad_(False) + _logger.info( + "Checkpoint %s carries %d generator_ema.* tensors; built the EMA " + "shadow from them (ema_kimg absent from this config). " + "use_ema_at_predict=%s selects which generator runs.", + ckpt_path, + ema_keys_in_ckpt, + self.use_ema_at_predict, + ) # strict=False: pre-modernization checkpoints don't carry # generator_ema.* / _lecam_ema_* keys. Filter missing-key warnings # to expected-missing prefixes; anything else is a genuine @@ -939,7 +1914,6 @@ def __init__( # future buffer added to generator_ema that an old ckpt lacks) — # silently half-seeding would produce nonsense at the partial layers. if self.generator_ema is not None: - ema_keys_in_ckpt = sum(1 for k in state if k.startswith("generator_ema.")) ema_keys_expected = len(self.generator_ema.state_dict()) if ema_keys_in_ckpt == 0: self.generator_ema.load_state_dict(self.generator.state_dict()) @@ -1040,6 +2014,53 @@ def _adv_g_loss(self, d_real: list[Tensor] | None, d_fake: list[Tensor]) -> Tens raise ValueError("RpGAN G loss requires fresh d_real logits; got None.") return rpgan_g_loss(d_real, d_fake) + def _compute_recon(self, pred: Tensor, target: Tensor, batch: Sample) -> tuple[Tensor, dict[str, Tensor]]: + """Compute the generator reconstruction term, with fg_mask when present. + + Returns the scalar term and any per-component breakdown the loss exposes + (empty for plain L1). The components come from the loss itself rather + than being re-derived here: they are the campaign's only monitor on + whether ``lambda_l1`` still balances the adversarial term after the + objective is swapped, and a re-derivation would silently fork from what + is actually optimized. + + Parameters + ---------- + pred : Tensor + Generator output. + target : Tensor + Ground truth. + batch : Sample + The batch, read for an optional ``fg_mask``. + + Returns + ------- + tuple of (Tensor, dict of str to Tensor) + Scalar reconstruction loss and its components. + """ + # With seg_aux the mask belongs to the aux term alone (see _compute_seg_aux). + if "fg_mask" not in batch or self.seg_aux is not None: + return self.recon_loss(pred, target), {} + if not self._recon_accepts_fg_mask: + raise TypeError( + f"{type(self.recon_loss).__name__} does not accept 'fg_mask'. " + f"Use SpotlightLoss or remove fg_mask_key from the data config." + ) + # Re-binarize: the mask rides through the same gpu_augmentations as the + # image (hcs.py patches it into the list), and the affine resamples with + # bilinear interpolation, so ~40% of voxels arrive with fractional + # weight. SpotlightLoss would then compute a soft-weighted mean and a + # soft-vs-soft Dice — different semantics from the flip-only FNet arms. + fg_mask = (batch["fg_mask"] > 0.5).float() + if not self._recon_returns_components: + return self.recon_loss(pred, target, fg_mask=fg_mask), {} + return self.recon_loss(pred, target, fg_mask=fg_mask, return_components=True) + + def _compute_seg_aux(self, pred: Tensor, target: Tensor, batch: Sample) -> tuple[Tensor, Tensor]: + """Compute the unweighted ``seg_aux`` Dice and its valid-patch count.""" + dice, comps = self.seg_aux(pred, target, _require_fg_mask(batch), return_components=True) + return dice, comps["n_valid"] + def training_step(self, batch: Sample, batch_idx: int) -> None: """Run one alternating D/G optimization step. @@ -1135,8 +2156,14 @@ def training_step(self, batch: Sample, batch_idx: int) -> None: adv_loss = self._adv_g_loss(d_real_for_g, d_fake_for_g) else: adv_loss = self._adv_g_loss(None, d_fake_for_g) - l1_loss = F.l1_loss(pred, target) - g_loss = self.lambda_adv * adv_loss + self.lambda_l1 * l1_loss + recon_train, recon_components = self._compute_recon(pred, target, batch) + g_loss = self.lambda_adv * adv_loss + self.lambda_l1 * recon_train + if self.seg_aux is not None: + dice_train, dice_n_valid = self._compute_seg_aux(pred, target, batch) + g_loss = g_loss + self.seg_aux_weight * dice_train + if self.seg_consistency is not None: + segcons_train, segcons_components = self.seg_consistency(pred, target, return_components=True) + g_loss = g_loss + self.seg_consistency_weight * segcons_train opt_g.zero_grad(set_to_none=True) self.manual_backward(g_loss) opt_g.step() @@ -1177,8 +2204,18 @@ def training_step(self, batch: Sample, batch_idx: int) -> None: "loss/d_train": d_loss, "loss/g_train": g_loss, "loss/g_adv_train": adv_loss, - "loss/g_l1_train": l1_loss, + # Key kept as `g_l1_train` even when recon_loss is not L1: renaming it + # would break the existing dashboards and three engine tests. It now + # carries whatever reconstruction term is configured, which is why the + # components below are logged alongside it rather than instead of it. + "loss/g_l1_train": recon_train, } + log_payload.update({f"loss/g_recon_{name}_train": value for name, value in recon_components.items()}) + if self.seg_aux is not None: + log_payload["loss/g_dice_train"] = dice_train + log_payload["loss/g_dice_n_valid_train"] = dice_n_valid + if self.seg_consistency is not None: + log_payload.update({f"loss/g_{name}_train": value for name, value in segcons_components.items()}) self.log_dict( log_payload, on_step=True, @@ -1196,7 +2233,7 @@ def training_step(self, batch: Sample, batch_idx: int) -> None: self.log("reg/r2", r2_value.detach(), on_step=True, on_epoch=True, sync_dist=False) def validation_step(self, batch: Sample, batch_idx: int, dataloader_idx: int = 0) -> Tensor: - """Compute generator L1 validation loss(es) and capture samples. + """Compute generator reconstruction validation loss(es) and capture samples. Always runs the raw generator forward and accumulates into ``validation_losses_raw`` (drives the back-compat ``loss/validate`` @@ -1220,19 +2257,26 @@ def validation_step(self, batch: Sample, batch_idx: int, dataloader_idx: int = 0 Returns ------- Tensor - Scalar L1 loss on this batch (raw generator). + Scalar reconstruction loss on this batch (raw generator). This is + whatever ``recon_loss`` is configured to be, matching the objective + the G step optimizes — otherwise ``monitor: loss/validate_ema`` + would select checkpoints against a different objective. """ source: Tensor = batch["source"] target: Tensor = batch["target"] # Raw generator pass (always). pred_raw = self.generator(source) - l1_raw = F.l1_loss(pred_raw, target) - if dataloader_idx + 1 > len(self.validation_losses_raw): - self.validation_losses_raw.append([]) - self.validation_losses_raw[dataloader_idx].append((l1_raw.detach(), source.shape[0])) + recon_raw, _ = self._compute_recon(pred_raw, target, batch) + _record_val_loss(self.validation_losses_raw, dataloader_idx, recon_raw.detach(), source.shape[0]) + if self.seg_aux is not None: + dice_raw, _ = self._compute_seg_aux(pred_raw, target, batch) + _record_val_loss(self.validation_dice_raw, dataloader_idx, dice_raw.detach(), source.shape[0]) + if self.seg_consistency is not None: + segcons_raw = self.seg_consistency(pred_raw, target) + _record_val_loss(self.validation_segcons_raw, dataloader_idx, segcons_raw.detach(), source.shape[0]) self.log( f"loss/val/{dataloader_idx}", - l1_raw, + recon_raw, sync_dist=True, batch_size=source.shape[0], ) @@ -1241,13 +2285,17 @@ def validation_step(self, batch: Sample, batch_idx: int, dataloader_idx: int = 0 if self.generator_ema is not None: with torch.no_grad(): pred_ema = self.generator_ema(source) - l1_ema = F.l1_loss(pred_ema, target) - if dataloader_idx + 1 > len(self.validation_losses_ema): - self.validation_losses_ema.append([]) - self.validation_losses_ema[dataloader_idx].append((l1_ema.detach(), source.shape[0])) + recon_ema, _ = self._compute_recon(pred_ema, target, batch) + _record_val_loss(self.validation_losses_ema, dataloader_idx, recon_ema.detach(), source.shape[0]) + if self.seg_aux is not None: + dice_ema, _ = self._compute_seg_aux(pred_ema, target, batch) + _record_val_loss(self.validation_dice_ema, dataloader_idx, dice_ema.detach(), source.shape[0]) + if self.seg_consistency is not None: + segcons_ema = self.seg_consistency(pred_ema, target) + _record_val_loss(self.validation_segcons_ema, dataloader_idx, segcons_ema.detach(), source.shape[0]) self.log( f"loss/val_ema/{dataloader_idx}", - l1_ema, + recon_ema, sync_dist=True, batch_size=source.shape[0], ) @@ -1261,7 +2309,7 @@ def validation_step(self, batch: Sample, batch_idx: int, dataloader_idx: int = 0 self.validation_step_outputs.extend( detach_sample((source, target, pred_for_samples), self.log_samples_per_batch) ) - return l1_raw + return recon_raw def on_train_epoch_end(self) -> None: """Log accumulated training image samples and reset the buffer.""" @@ -1288,12 +2336,40 @@ def on_validation_epoch_end(self) -> None: _aggregate_validation_losses(self.validation_losses_ema), sync_dist=True, ) + # seg_aux Dice, logged apart so the monitors above stay reconstruction-only. + if self.validation_dice_raw: + self.log("loss/validate_dice", _aggregate_validation_losses(self.validation_dice_raw), sync_dist=True) + if self.validation_dice_ema: + self.log("loss/validate_ema_dice", _aggregate_validation_losses(self.validation_dice_ema), sync_dist=True) + if self.validation_segcons_raw: + self.log("loss/validate_segcons", _aggregate_validation_losses(self.validation_segcons_raw), sync_dist=True) + if self.validation_segcons_ema: + self.log( + "loss/validate_ema_segcons", _aggregate_validation_losses(self.validation_segcons_ema), sync_dist=True + ) self.validation_step_outputs.clear() self.validation_losses_raw.clear() self.validation_losses_ema.clear() + self.validation_dice_raw.clear() + self.validation_dice_ema.clear() + self.validation_segcons_raw.clear() + self.validation_segcons_ema.clear() def configure_optimizers(self): """Build two AdamW optimizers + WarmupCosine schedulers via the shared helper.""" + # __init__ adopts an EMA shadow from a checkpoint's own generator_ema.* keys + # even when the config omits ema_kimg -- a deliberate predict-side affordance + # (2bfa636b), since at inference only the shadow's existence matters. Training + # does need the decay constant: training_step computes + # 0.5 ** (bs / max(self.ema_kimg * 1000.0, 1e-8)) and would raise TypeError on + # step 1, after the allocation is already burned. Fail here instead -- Lightning + # calls this only under TrainerFn.FITTING, so predict is untouched. + if self.generator_ema is not None and self.ema_kimg is None: + raise ValueError( + "ckpt_path carries generator_ema.* tensors but this fit config sets no " + "ema_kimg, so the EMA shadow has no decay constant to update with. Set " + "ema_kimg to continue the EMA, or drop ckpt_path if the shadow is not wanted." + ) [opt_g], [sch_g] = configure_adamw_scheduler( self, self.generator, @@ -1355,9 +2431,32 @@ def predict_step(self, batch: Sample, batch_idx: int, dataloader_idx: int = 0) - source = batch["source"] original_shape = source.shape[2:] source = self._predict_pad(source) + # Inference uses EMA generator when available (and use_ema_at_predict=True). + generator = self._inference_generator() if self.predict_method == "full_image": - # Inference uses EMA generator when available (and use_ema_at_predict=True). - prediction = self._inference_generator()(source) + prediction = generator(source) + elif self.predict_method == "sliding_window": + # The ViT generator is fixed at input_spatial_size; tile larger + # inputs (e.g. the 640x960 A549 test) into overlapping windows. + if self.predict_phase_shifts: + prediction = _phase_shift_average( + generator, + source, + tuple(generator.input_spatial_size), + self.predict_overlap, + self.predict_phase_shifts, + blend=self.predict_blend, + ) + else: + prediction = _sliding_window_inference( + generator, + source, + tuple(generator.input_spatial_size), + self.predict_overlap, + blend=self.predict_blend, + ) else: - raise ValueError(f"Unknown predict_method: {self.predict_method!r}. Choose 'full_image'.") + raise ValueError( + f"Unknown predict_method: {self.predict_method!r}. Choose 'full_image' or 'sliding_window'." + ) return _center_crop_to_shape(prediction, original_shape) diff --git a/applications/dynacell/src/dynacell/evaluation/CLAUDE.md b/applications/dynacell/src/dynacell/evaluation/CLAUDE.md index c8c33eedc..0a9fe0b9c 100644 --- a/applications/dynacell/src/dynacell/evaluation/CLAUDE.md +++ b/applications/dynacell/src/dynacell/evaluation/CLAUDE.md @@ -5,9 +5,35 @@ computing) for any GPU-accelerated numerical work — image preprocessing before / after model inference, metric calculations, cropping/resizing, percentile clips, Gaussian filters, etc. Cubic is a hard runtime dependency of the eval extras (`applications/dynacell/pyproject.toml` -pins `cubic==0.7`, resolved from PyPI). Do not gate cubic imports behind `try/except` +pins `cubic @ git+…@v0.9.0a4`). Do not gate cubic imports behind `try/except` or fall back to scipy/skimage paths. +**The cubic version is part of the numeric contract, not just a dep.** Metric +values move across pins — measured 0.8.0a2 → 0.9.0a1: `Z_FSC_Resolution` ++30.9%, `XY_FSC_Resolution` +16.7%, `Spectral_PCC` ≤0.57%, `FRC_Resolution` ++0.52%, with `PCC`/`SSIM`/`NRMSE`/`PSNR`/`SI_*`/`PerCell_*`/`AP_*`/`mAP`/ +`instance_dice`/`MicroMS3IM`/CP columns all bit-identical. So: + +- `dynacell.evaluation.provenance.REQUIRED_CUBIC_VERSION` is the single + declared version; `provenance_test.py` pins it to every pyproject pin. +- `check_cubic_pin()` runs at both eval entry points and **fails the run** + for an unsupported runtime version. `CUBIC_RUNTIME_VERSIONS` explicitly + permits older environments; `require_cubic_workflows(target_name)` requires + the new workflow API only for ER and mitochondria. Do not downgrade either + gate to a warning. +- `save_metrics` stamps `metrics_provenance.json` beside the CSVs, and + `_final_metrics_cache_valid` refuses an unstamped or foreign-stamped cache. + Unstamped means "written before the stamp existed", i.e. an unknown pin — + it must recompute, unlike the per-extractor `preprocess_version` bootstrap + which treats an untagged entry as unconstrained. +- A bump measured to move no value beyond a stated tolerance lists the old + version under the new one in `CUBIC_VERSIONS_EQUIVALENT_TO` so its caches are still reused + (0.9.0a3, 0.9.0a2 and 0.9.0a1 under 0.9.0a4). The map is keyed by the + declared version, so the next bump reuses nothing until someone measures + equivalence against it. This map controls cache reuse only; it grants no + runtime API capability. Measurement scope and tolerances are recorded beside + each entry in `provenance.py`. + The GPU-resident Cellpose-SAM entry point is `cubic.segmentation.segment_cpsam` (single host→device upload, masks returned to host; GPU-only by contract). The marker-controlled watershed @@ -20,6 +46,52 @@ Below is the same guidance the upstream cubic repository ships in its adding GPU-aware code here.** It is also fine to read `cubic/AGENTS.md` directly at `../cubic/` for the canonical version. +## ⚠️ Always verify data format + normalization for pretrained models + +Every pretrained model used at eval time — segmentors (Cellpose / +CELL-DINO / cpsam) and deep feature extractors (DINOv3, DynaCLR, +CELL-DINO, MorphEm) — has a **specific input contract**: expected value +range, dtype, channel count, and normalization recipe. These are *not* +interchangeable, and getting one wrong fails silently (plausible-looking +but meaningless features / masks), not loudly. Before wiring or editing +any model call, confirm all of the following against the model's own +docs/source — do not assume: + +- **Value range and normalization.** Look up what the model was *trained* + on and match it. Common recipes here: robust percentile clip + (`_robust_norm`, the shared `build_crops` recipe), per-image spatial + z-score (DynaCLR's `NormalizeSampled`, MorphEm's `PerImageNormalize` / + InstanceNorm2d), ImageNet mean/std (DINOv3). A train/test normalization + mismatch (e.g. feeding bounded [0,1] to a z-score-trained encoder) is a + real bug even when nothing crashes. +- **No double-normalization.** If crops are already normalized upstream + in `build_crops`, a processor/transform that *also* rescales (e.g. the + HF `AutoImageProcessor`'s default `do_rescale=True` → ÷255, or a second + z-score) silently destroys the signal. Trace the full path from raw + array to model input and count every rescale exactly once. Pass + `do_rescale=False` when the input is already float-normalized. +- **GT vs prediction parity.** GT and predicted intensities live in + **different value ranges**. The normalization must be applied + identically to both so their features are comparable — a min/max or + raw-range recipe makes GT and pred asymmetric; a shared robust/affine + recipe keeps them aligned. +- **dtype.** `np.percentile` upcasts to float64; model weights are + float32. Cast crops back to float32 before the model (`.astype( + np.float32, copy=False)`) or conv/linear layers raise `Input type + (double) and bias type (float) should be the same`. +- **Cache invalidation.** Any change to a recipe must bump that + extractor's `PREPROCESS_VERSION` (see + `_auto_invalidate_on_preprocess_version_mismatch` in + `pipeline_cache.py`), or stale caches from the old recipe silently + survive. + +When adding a new pretrained model, read its published preprocessing +(model card / training repo) and add a regression test that asserts the +tensor reaching the model has the expected range/dtype — see the +`test_dinov3_*` / `test_dynaclr_*` / `test_morphem_*` tests in +`tests/test_evaluation_extractors.py` and the hot-pixel test in +`tests/test_evaluation_metrics.py`. + ## Device management (`cubic.cuda`) Core utilities for device-agnostic computation: @@ -158,3 +230,77 @@ so the GPU path is what runs. operations. - Don't gate cubic imports with `try/except ImportError: None`. Cubic is a hard dep here. If it's missing, the pipeline is broken — fail loud. + +## Eval runtime parallelism — grouped eval is serial-amortized; `--parallel` is a predict lever + +`dynacell evaluate-grouped` loads the model stack (SuperModel + DINOv3 + +DynaCLR + CELL-DINO, ~60 s, ~15 GB) **once** and reuses it across every +condition in the bucket. That amortization is the whole point of the grouped +path — **do not parallelize conditions or FOVs inside it.** `--parallel` and +`runtime.executor=process` are *predict* levers, not eval ones: on a grouped +bucket each condition's worker pool independently reloads the full stack +(`evaluate_predictions_grouped` prints a `!!! WARNING !!!` — `~30-90 s × +N_workers × N_conditions` of redundant cold-start), and the deep-feature +forwards still serialize on the one GPU under the fcntl lock, so there is no +compute win to offset the reloads. + +- **Predicts are the opposite** (cheap load, ~10 GB, GPU-light): `--parallel 2` + is a confirmed win there (2-up on A40). See `applications/dynacell/CLAUDE.md` + "Predict submission modes". +- Submit buckets with `tools/run_eval_direct.slurm`; restrict one to some of its + conditions with `only_conditions=[...]`. +- **The real eval-side parallelism lever is bucket-level:** run independent + grouped buckets on separate GPUs. When buckets share a GT cache + (`sec61b`/`tomm20`, keyed by `(gene_cond, halfwidth)`), a warm-first `afterok` + chain (one bucket warms, the rest read) is a *true* dependency only while the + cache is cold — once it is warm at the target halfwidth, that afterok is a + **false sync point** and the buckets can run concurrently (all read-only). + Drop it only after confirming warm-state, else concurrent buckets race the + drop-and-recompute write. + +## Cache-staleness checks: gate on the mean PCC, and prove staleness before recomputing + +`PCC` is the right **signal** for "was this eval cache produced from the arrays that +are on disk now?" — it is affine-invariant, so a metric-definition change (e.g. the +min-max → scale-invariant switch) cannot move it, and only a genuine array change +can. `pixel_scaling_backfill.py` uses it as its write gate for exactly that reason. + +**But a per-row relative tolerance is the wrong test.** PCC's numerator is a +difference of nearly-cancelling sums, so its float32 error is set by cancellation, +not by magnitude. On a near-degenerate prediction the value itself is tiny — FNet3D +on HEK mitochondria sits at **PCC 0.003**, no correlation at all — and cancellation +alone moves one row by ~1e-3, i.e. **30% relative**. Any `rtol` check fires. +Measured 2026-08-03: `rtol=1e-3, atol=1e-5` per row flagged **19 of 648** conditions +as stale cache, and every one that fed a table was a false positive. + +Gate on the **mean** instead: `PCC_MEAN_ATOL = 5e-4`, tighter than the 3-decimal +rounding the tables publish, so a mean inside it cannot change a published cell +while a real re-predict moves it well outside. A per-row failure that clears the +mean is reported `reproduced_mean` — written, but still visible in the audit. Do not +collapse that into `reproduced`, and do not widen the per-row `rtol` instead. + +**A staleness verdict is a hypothesis, not a finding. Run these four before +spending GPU on a re-eval** — all cheap, and together they settled all 19: + +1. **Compare the mean against an independent published artifact.** The one flagged + cell that fed a table reproduced its published `0.540` as `0.5396`. PCC is + affine-invariant, so identical PCC ⇒ identical arrays. That one check was + decisive. +2. **Chunk-mtime prediction *and* GT against the eval CSV mtime**, full scan: + `find -type f -not -name '*.json' -printf '%T@\n' | sort -rn | head -1`. + All three suspect dirs had both stores older than the eval and untouched since, + so no data change was possible. Never sample via `find | head | xargs stat` — a + truncated listing gives a wrong "newest chunk" and sends you down a false trail. +3. **Check for a live writer.** Two flagged dirs were being rewritten at that moment + by a running eval; the gate was comparing against a cache mid-write. `squeue` + before concluding anything about a cache. +4. **`git log` the config surface** against the eval date: the leaf YAML, the dataset + manifest under `_manifests//manifest.yaml`, and `_configs/eval.yaml`. + +Note that `focus.*` / `segmentation.slice_selection` affect **instance segmentation +and the deep-feature slab only — not pixel metrics.** Don't reach for them to +explain a moved pixel number. + +A gate that fails **closed** (refuses to write, reports `stale_cache`) is safe to +leave over-sensitive, because its only cost is a line in a report. So prefer false +positives in the gate — but never let a false positive drive a re-run. diff --git a/applications/dynacell/src/dynacell/evaluation/README.md b/applications/dynacell/src/dynacell/evaluation/README.md index 07523e223..10b6b9a0c 100644 --- a/applications/dynacell/src/dynacell/evaluation/README.md +++ b/applications/dynacell/src/dynacell/evaluation/README.md @@ -1,307 +1,372 @@ # dynacell.evaluation -End-to-end evaluation pipeline for virtual staining predictions against fluorescence ground truth. +Scores virtual-staining predictions against fluorescence ground truth at three levels: pixel fidelity, segmentation, and single-cell phenotype features. -## Components +- [Pipeline](#pipeline) +- [Running evaluations](#running-evaluations) +- [Configuration](#configuration) +- [Segmentation](#segmentation) +- [Metrics](#metrics) +- [Caches](#caches) +- [Outputs](#outputs) +- [Modules](#modules) -| Module | Purpose | -|---|---| -| `pipeline.py` | Hydra orchestrator. CLIs: `dynacell evaluate` (single-condition) and `dynacell evaluate-grouped` (one model load, N I/O conditions). | -| `metrics.py` | Pixel, mask, and feature metrics (CP regionprops + DINOv3 + DynaCLR + CELL-DINO), computed symmetrically for GT/predictions and combined pairwise. | -| `segmentation.py` | `aicssegmentation` workflows + SuperModel for `nucleus`/`membrane`. | -| `cache.py`, `pipeline_cache.py` | Artifact cache: on-disk layout, manifest, identity check, per-FOV load-or-compute wrappers, batched `precompute_deep_features`. | -| `model_loader.py` | Shared `load_eval_models(config, flags=...)` returning an `EvalModels` bundle. Used by both `evaluate` and `precompute-gt`. | -| `runtime.py` | BLAS/OMP thread caps, `ProcessPoolExecutor` worker initializer, `gpu_serialization_lock`, region timers. | -| `precompute_cli.py` | `dynacell precompute-gt` — fills the GT cache without running the eval loop. | -| `utils.py` | `DinoV3FeatureExtractor`, `DynaCLRFeatureExtractor`, `CellDinoFeatureExtractor`, plot helpers. | -| `_configs/*.yaml` | Hydra schemas: `eval.yaml`, `precompute.yaml`, `eval_grouped.yaml`. | - -Other files (`io.py`, `formatting.py`, `spectral_pcc/`) house readers and bead/PSF diagnostics. Pixel metrics (PCC, SSIM, NRMSE, PSNR) are now backed by `cubic.metrics`. - -## Inputs - -- `io.pred_path` — model predictions, HCS OME-Zarr (channel: `io.pred_channel_name`) -- `io.gt_path` — fluorescence ground truth (channel: `io.gt_channel_name`) -- `io.cell_segmentation_path` — *optional* precomputed cell segmentation HCS OME-Zarr. Required when `compute_feature_metrics=true` or when building CP/DINOv3/DynaCLR/CELL-DINO cache entries. Position layout must match GT/pred 1:1. -- `io.gt_cache_dir`, `io.pred_cache_dir` — *optional* artifact cache directories; must be distinct. See [Caches](#caches). - -## Quick start - -```bash -uv run dynacell evaluate \ - target=er_sec61b \ - predict_set=ipsc_confocal \ - io.pred_path=/hpc/.../fnet3d_sec61b.zarr \ - save.save_dir=/hpc/.../eval_fnet3d_sec61b -``` +## Pipeline -Add `compute_feature_metrics=true` to enable feature metrics. Smoke test on a subset of FOVs with `limit_positions=N`. +`dynacell evaluate` runs these steps for one prediction store: -## Submission tooling - -| Tool | Use case | -|---|---| -| `dynacell evaluate ...` / `dynacell evaluate-grouped leaf=...` | Run a single eval (or grouped multi-condition eval) inline. Foreground, no sbatch. | -| `tools/submit_evaluation_job.py ` | Submit a single eval leaf as one sbatch. Mirror of `submit_benchmark_job.py` for eval. | -| `tools/submit_evaluation_batch.py ` | Submit N eval leaves as one sbatch with `--parallel N` (chunked waves of N concurrent processes on the shared GPU). Used by `tools/evaluate_batch.sh`. | -| `tools/run_eval_direct.slurm ` | Direct-launch slurm script for hand-authored eval leaves that bypass the submit helpers. | - -For multi-condition evals over `(model, organelle) × {mock, denv, zikv}`, prefer `evaluate-grouped` over N separate `evaluate` calls — it amortizes the ~30–90 s SuperModel + DINOv3 + DynaCLR + CELL-DINO load across conditions. See [`applications/dynacell/CLAUDE.md`](../../../CLAUDE.md#grouped-multi-condition-eval) "Grouped multi-condition eval" for the executor + cache-mode tradeoffs. - -For the predict-side submission tooling (`submit_benchmark_batch.py` + `predict_batch.sh`, with serial / `--array` / `--parallel P` modes), see [`applications/dynacell/CLAUDE.md`](../../../CLAUDE.md#predict-submission-modes) "Predict submission modes" and the [benchmarks README](../../../configs/benchmarks/virtual_staining/README.md#multi-leaf-submission-with-submit_benchmark_batchpy). - -## Configuration - -`dynacell evaluate` is a Hydra entrypoint — override any field with `key=value` (CLI overrides win over groups). Settings that travel with a (target, marker, dataset) combination live in named Hydra **config groups**: - -| Group | Options | What it sets | Source | -|---|---|---|---| -| `target` | `er_sec61b`, `mito_tomm20`, `membrane`, `nucleus` | `target_name`, `benchmark.dataset_ref.target` | repo-checkout `_internal/shared/eval/target/` | -| `predict_set` | `ipsc_confocal` | `benchmark.dataset_ref.dataset` | in-package | -| `feature_extractor/dinov3` | `lvd1689m` | `feature_extractor.dinov3.pretrained_model_name` | in-package | -| `feature_extractor/dynaclr` | `default` | `feature_extractor.dynaclr.checkpoint` + 8-field encoder dict | repo-checkout `_internal/shared/eval/feature_extractor/dynaclr/` | -| `leaf` | `///eval__` | Composes all of the above for one canonical run | repo-checkout `_internal/leaf/` (symlink tree) | +1. **Check saved metrics.** If `save.save_dir` already holds metrics that are still valid (see [Reusing saved metrics](#reusing-saved-metrics)), load them and stop. +2. **Compose and validate the config.** Fields under `benchmark.dataset_ref` are resolved from the dataset manifest. The installed cubic version and the segmentation backend/target pairing are checked, and so is the CP reference when feature metrics are on. +3. **Load models**: the segmenter, plus the feature extractors when `compute_feature_metrics=true`. +4. **Open stores** (prediction, GT, cell segmentation, optional separate nuclei store) and reconcile positions. Every store must hold the same positions with the same number of timepoints. +5. **Precompute deep features** for both sides in batches, unless the cache already holds them. +6. **For each FOV and timepoint:** + 1. compute pixel metrics on the full volume; + 2. segment GT and prediction, then compute mask metrics; + 3. extract per-cell features and score each GT/prediction pair. +7. **Dataset-level feature metrics**: distribution distances (KID, FID, precision/recall, MIND), median cosine, and a real-vs-predicted linear probe, per feature space. +8. **Save** CSV/NPY tables, plots, single-cell embeddings, the segmentation plate and `metrics_provenance.json`. -Select a group: `=