Marigold V2: Revisiting Diffusion Transformers for Monocular Depth Estimation

3.1 Discriminative monocular depth

Three generations:

1. Single-domain models trained with ground truth, self-supervision, or proxy annotations. No cross-dataset generalization.
2. Affine-invariant, mixed-dataset models — the MiDaS lineage — which achieve zero-shot cross-dataset transfer by giving up absolute scale and shift.
3. ViT + million-scale models: Depth Anything V1/V2, MoGe, MoGe-2, π³, spanning affine-invariant, universal metric, and video depth.

These are strong. MoGe-2 and π³ appear in Table 1 and are not embarrassed by Marigold V2. The paper’s criticism is about annotation supply and quality, not about architecture.

3.2 Generative priors

The paper sorts prior work into three families:

The historical arc: early work (Marigold V1, GeoWizard, DepthFM) built on Stable Diffusion’s convolutional U-Net. The generative community then migrated to Diffusion Transformers — PixArt-α, SD3, FLUX, Qwen — and repurposing became “costlier due to the higher complexity of DiTs.”

The concrete cost numbers the paper cites are the motivation for the entire contribution:

• DICEPTION: 96 GPU-days
• Lotus-2: 8 GPUs

Note that LoRA alone does not solve this. The paper is explicit that “parameter-efficient methods like LoRA don’t always reduce this burden.” The memory wall is the frozen base weights in fp16/bf16, not the optimizer state. This is why the Q in QLoRA is load-bearing here, not incidental.

3.3 Representation alignment

REPA and iREPA showed that regularizing diffusion internals against a pretrained visual encoder improves “semantic fidelity and training convergence.” Applied to depth:

• DepthMaster: aligns intermediate U-Net features with DINOv2 features of the input image.
• Pixel-Perfect Depth: injects semantic representations via a Semantics-Prompted DiT.

Marigold V2 inverts the target:

iREPA-depth “draws its alignment target from a frozen DINOv3 encoder applied to the ground-truth depth map rather than the input image.”

Two consequences, both stated by the authors:

1. It gives a “more direct supervisory signal for geometric reconstruction” — you are asking the DiT’s internals to look like the semantics of the answer, not of the question.
2. It has no inference-time dependency. The DINOv3 encoder is a training-time-only object. DepthMaster-style RGB alignment likewise doesn’t need it at inference, but Semantics-Prompted approaches do; iREPA-depth stays free.

3.4 Detail and artifact handling

The paper’s survey of the detail problem, and why each prior fix is partial:

The claimed gap:

“no existing approach jointly addresses detail preservation and robust supervision under noisy or ambiguous ground-truth within a single-step VAE-based generative framework”

This is a narrow, defensible gap statement — note how many qualifiers it carries. It is not “nobody does detail”; it is “nobody does detail and noise-robustness and single-step and VAE-based, together.”

4.0 The pipeline at a glance

Reconstructed as a flowchart:

flowchart TB
    subgraph S1["STAGE 1 — 160K steps, ~5 days"]
        direction TB
        I1["Input image I"] --> VE1["VAE encoder ℰ_vae<br/>FROZEN"]
        GT1["Normalized GT depth d<br/>(3-channel grayscale)"] --> VE1
        VE1 --> ZI1["z_I = ℰ_vae(I)"]
        VE1 --> ZD1["z_d = ℰ_vae(d)"]
        ZI1 --> DIT1["DiT f_θ<br/>Qwen-Image-Edit-2509<br/>4-bit base + rank-128 LoRA<br/>TRAINABLE (adapters only)"]
        ZD1 --> VTGT["target velocity<br/>v = z_I − z_d"]
        DIT1 --> PRED1["f_θ(z_I, t=0.5)"]
        PRED1 --> LLAT["ℒ_latent = ‖f_θ(z_I,t) − v‖²₂"]
        VTGT --> LLAT
        PRED1 --> DEC1["VAE decoder 𝒟_vae<br/>FROZEN"]
        DEC1 --> DHAT1["d̂"]
        DHAT1 --> LPIX["ℒ_pix (L1)"]
        DHAT1 --> LGRAD["ℒ_grad (L1 on ∇x, ∇y)"]
        DIT1 -.->|internal features| LIREPA["ℒ_iREPA"]
        GT1 --> DINO["DINOv3 encoder<br/>FROZEN<br/>applied to GT DEPTH"]
        DINO --> LIREPA
    end

    S1 ==> CKPT["Stage-1 checkpoint<br/>(already SOTA-competitive)"]

    subgraph S2["STAGE 2 — 30K steps, ~1 day"]
        direction TB
        CKPT2["Stage-1 weights"] --> DIT2["DiT f_θ<br/>QLoRA adapters<br/>TRAINABLE"]
        DIT2 --> DEC2["VAE decoder 𝒟_vae<br/>UNFROZEN — TRAINABLE"]
        DEC2 --> DHAT2["d̂"]
        DHAT2 --> SINK["ℒ_SinkLoss<br/>Sinkhorn OT on 5×5 blocks"]
        DIT2 -.->|internal features| LIREPA2["ℒ_iREPA (retained, λ=0.2)"]
    end

    CKPT ==> S2
    S2 ==> FINAL["Marigold V2"]

    style S1 fill:#e8f0fe,stroke:#4a6fa5
    style S2 fill:#fdf0e8,stroke:#a56f4a
    style FINAL fill:#e8f5e9,stroke:#4a8f5a

And the inference path, which is deliberately trivial — one VAE encode, one DiT forward, one VAE decode:

flowchart LR
    I["RGB image I"] --> E["ℰ_vae"]
    E --> ZI["z_I"]
    ZI --> F["DiT f_θ<br/>single forward pass<br/>t = 0.5"]
    F --> V["predicted velocity"]
    ZI --> SUB(("−"))
    V --> SUB
    SUB --> ZD["ẑ_d = z_I − f_θ(z_I, t)"]
    ZD --> D["𝒟_vae"]
    D --> OUT["d̂ — affine-invariant log-depth"]

    style F fill:#e8f0fe,stroke:#4a6fa5
    style OUT fill:#e8f5e9,stroke:#4a8f5a

No iterative denoising. No ensembling over noise seeds (Marigold V1’s expensive trick). No DINOv3 at inference. This is the efficiency claim.

4.1 Depth normalization

Metric depth D is mapped to an affine-invariant log-depth target d:

\[ d = 2\left[\frac{\log(D+\varepsilon) - d_{2}}{d_{98} - d_{2}} - \frac{1}{2}\right] \]

Three design decisions are packed into this one line:

1. Log space. Table 4 is the justification — log-depth beats both linear depth and disparity (4.72 vs 5.04 vs 5.28 AbsRel). This is not arbitrary: AbsRel is a relative error metric, so an L1 loss in log space is approximately an L1 loss on relative error, which aligns the training objective with the evaluation metric. Linear-depth L1 over-weights far pixels; disparity over-weights near ones.
2. Percentile clipping, not min/max. Using \(d_2\)/\(d_{98}\) rather than the extremes makes normalization robust to a handful of sensor outliers or sky pixels that would otherwise compress the entire usable range.
3. Affine invariance. Discarding absolute scale and shift is what makes cross-dataset training possible at all — HyperSim and vKITTI have incomparable depth ranges.

Then a pragmatic trick:

“The normalized depth map is encoded as a grayscale RGB image by replicating the same normalized depth value across the three color channels.”

This is the key to reusing the pretrained VAE untouched. The VAE expects 3-channel images in \([-1,1]\); a replicated depth map is exactly that. No new encoder, no architectural surgery, and — importantly — the VAE’s learned priors about natural-image structure transfer to depth maps, which are themselves piecewise-smooth-with-sharp-edges in much the way images are.

4.2 Diffusion transformer adaptation

Base model: Qwen-Image-Edit-2509.

This choice deserves a beat. It is an image-editing model, not a text-to-image model. An editing model is already trained on the conditional task “given this image, produce a related image” — structurally the same shape as “given this image, produce its depth map.” The conditioning pathway already exists and is already aligned to spatial correspondence with the input. That is a materially easier starting point than a T2I model, where the image-conditioning path has to be grafted on.

Components:

Forward formulation. Both image and depth are encoded into the shared latent space:

\[ z_I = \mathcal{E}_{vae}(I), \qquad z_d = \mathcal{E}_{vae}(d) \]

The DiT is trained to regress the velocity between them:

\[ v = z_I - z_d \]

\[ \mathcal{L}_{latent} = \lVert f_\theta(z_I, t) - v \rVert_2^2 \]

at a fixed timestep \(t = 0.5\).

This is the crucial simplification, and it is worth being precise about what it means. In flow-matching / rectified-flow training you would sample \(t \sim \mathcal{U}[0,1]\) and learn the velocity field along the whole trajectory, then integrate at inference. Here the model is trained at a single point on the trajectory and the “ODE integration” collapses to one Euler step of size 1:

\[ \hat{z}_d = z_I - f_\theta(z_I, t) \]

\[ \hat{d} = \mathcal{D}_{vae}(\hat{z}_d) \]

So this is not really a diffusion model at inference. It is a deterministic feed-forward regressor that inherits diffusion-pretrained weights. The generative machinery is a weight-initialization and architecture story, not a sampling story. (This is a continuation of what Lotus and GenPercept established: for a deterministic dense-prediction target, the stochasticity of diffusion is a cost, not a benefit.)

Pixel-space auxiliary losses. Because the decode path is differentiable, supervision can be applied after decoding rather than only in latent space:

\[ \mathcal{L}_{pix} = \lVert \hat{d} - d \rVert_1 \]

\[ \mathcal{L}_{grad} = \lVert \nabla_x \hat{d} - \nabla_x d \rVert_1 + \lVert \nabla_y \hat{d} - \nabla_y d \rVert_1 \]

\(\mathcal{L}_{grad}\) is the classic multi-scale-gradient idea: penalizing gradient mismatch directly supervises edges, which an L1-on-values loss under-weights (an edge is a tiny fraction of pixels). Its weight is \(\lambda_{grad} = 5.0\) — five times the value losses — which tells you how much the authors are willing to pay for boundary fidelity.

4.3 iREPA-depth: semantic regularization from the answer, not the question

“We regularize the internal DiT representations using pretrained visual features, encouraging the model to also preserve semantically-meaningful structure.”

Mechanism: a frozen DINOv3 encoder produces target features; the DiT’s internal representations are aligned to them.

The inversion: targets come from the ground-truth depth map, not the RGB image.

The ablation is the argument. From Table 3 at 30K steps:

iREPA-depth wins on all five datasets against iREPA-rgb. Not by much — ~1–3% relative — but monotonically, which is more convincing than a large win on one benchmark.

Why it should work. DINOv3 features of a depth map encode “what regions are coherent objects with coherent geometry.” Asking the DiT’s internals to match those features is asking it to have an internal object/surface decomposition of the thing it is predicting. RGB features encode object identity and texture — informative, but they also encode things depth should ignore (albedo, shadows, print on a surface), which is arguably why the RGB variant is measurably worse.

LPIPS is the natural baseline here because it is also a pretrained-feature-space loss — the comparison isolates which feature space, not whether to use one.

Stage-1 total objective:

\[ \mathcal{L}_{DiT} = \lambda_{latent}\mathcal{L}_{latent} + \lambda_{pix}\mathcal{L}_{pix} + \lambda_{grad}\mathcal{L}_{grad} + \lambda_{iREPA}\mathcal{L}_{iREPA} \]

NOT STATED in the recoverable text: which DINOv3 variant (ViT-S/B/L/H), which DiT block the alignment is taken from, and what projection head maps DiT feature dimension to DINOv3 feature dimension. REPA-family work conventionally uses an early-to-middle block and a small MLP projector, but do not assume this — check the released code before reimplementing.

4.4 SinkLoss: refusing to fit the noise

This is the paper’s most interesting contribution, and the one most likely to transfer to other problems.

flowchart TB
    A["Predicted d̂ and GT d"] --> B["Tile into non-overlapping<br/>K×K blocks, K = 5"]
    B --> C["Per block: 25 predicted values,<br/>25 ground-truth values"]
    C --> D["Cost matrix<br/>C_ij = |d̂_i − d_j|<br/>(25 × 25)"]
    D --> E{"Validity mask<br/>m_i · m_j = 1 ?"}
    E -->|yes| F["C̃_ij = C_ij"]
    E -->|no| G["C̃_ij = B = 10⁶<br/>penalizes whole row AND column"]
    F --> H["Entropic OT:<br/>M = argmin ⟨M,C̃⟩ − τ·H(M)<br/>τ = 0.1, uniform marginals 1/K²"]
    G --> H
    H --> I["Sinkhorn–Knopp,<br/>5 iterations,<br/>log domain for stability"]
    I --> J["ℒ = Σ m_i m_j M_ij C_ij / Σ m_i m_j M_ij"]
    J --> K["Average over blocks<br/>with valid ground truth"]

    style H fill:#e8f0fe,stroke:#4a6fa5
    style K fill:#e8f5e9,stroke:#4a8f5a

6.1 Zero-shot affine-invariant depth (Table 1)

Metrics: AbsRel (mean absolute relative error, ↓) and δ₁ (% of pixels within a 1.25× factor of ground truth, ↑). Evaluation uses RANSAC-based robust alignment to ground-truth metric depth before computing metrics, following the Pixel-Perfect Depth protocol.

Reading this honestly:

• Against the ~74K-sample cohort (the fair comparison — Marigold V1, DepthFM, Lotus/Lotus-2, PPD, DepthMaster, FE2E), Marigold V2 wins every single column. That is a clean result.
• The headline 16–26%. KITTI 6.5 → 5.4 vs FE2E is 17%. ETH3D 3.8 → 2.8 is 26%. NYUv2 is 3.8 → 3.6, about 5%. The abstract quotes the two best columns. Not misleading — it names KITTI and ETH3D explicitly — but do not generalize it.
• π³ is the elephant. With >9M training samples it beats Marigold V2 on NYUv2 (2.9 vs 3.6), KITTI δ₁ is close (96.7 vs 97.4 — Marigold wins), ETH3D is a near-tie (2.9 vs 2.8 — Marigold wins), ScanNet favors π³ (2.1†), DIODE favors π³ (4.4 vs 5.2). The dagger on π³’s ScanNet entry suggests a footnoted caveat (likely training-data overlap) that I could not recover. Marigold V2 is not uniformly SOTA across all methods; it is SOTA at its data scale and competitive well above it.
• MoGe’s DIODE collapse (29.0 AbsRel, 70.0 δ₁) is a nice illustration of the paper’s own framing about discriminative models and out-of-distribution corner cases.
• Improvement is largest where scenes are hardest. ETH3D and KITTI — high dynamic range, outdoor, thin structures — improve most. NYUv2 and ScanNet — indoor, textured, already near-saturated — improve least. Consistent with the claim that the contributions target detail and boundary quality specifically.

6.2 Edge-aware evaluation (Table 2)

SEE_k (Soft Edge Error): at depth discontinuities, the minimum absolute error between predicted disparity and any ground-truth disparity within a k×k patch. Lower is better.

Note that SEE and SinkLoss share a philosophy — both permit local spatial slack. That is a real methodological caveat: the training objective is structurally aligned with this evaluation metric in a way that competitors’ objectives are not. It does not invalidate the result (SEE predates this paper and is a reasonable measure of boundary quality) but it is not an independent test either.

Evaluated on the HyperSim test set:

~13% better than PPD at k=3, and the margin holds across k. Only two baselines, both detail-specialists — a deliberately hard, narrow comparison.

6.3 Ablations (Table 3)

Full Stage-1 ablation:

Three things to notice, one of them awkward:

1. Adding \(\mathcal{L}_{pix}\) makes AbsRel worse on NYUv2 (4.53 → 4.70), KITTI (7.26 → 7.84), and ETH3D (4.25 → 4.32), while improving δ₁ everywhere. A pixel-space L1 that hurts a pixel-space relative-error metric is counterintuitive; the most likely explanation is that L1 through a frozen decoder pulls toward decoder-reconstructible (i.e. smoother) outputs. It is included anyway, presumably because it is a prerequisite for \(\mathcal{L}_{grad}\) and the Stage-2 pixel-space machinery.

2. Training length dominates every loss choice. 30K → 160K steps improves NYUv2 from 4.36 → 3.62 — a bigger delta than every loss ablation combined. This is the honest summary of Table 3: the losses give a few percent; the compute gives ~17%.

3. At 160K steps, iREPA-depth’s benefit is ambiguous. It worsens NYUv2 (3.62 → 3.68) and KITTI (5.27 → 5.30), and improves ETH3D (2.84 → 2.68), ScanNet (3.84 → 3.81), DIODE (5.16 → 5.02). The clean 5/5 sweep at 30K becomes 3/5 at convergence. The charitable reading — supported by Figure 3 — is that iREPA-depth buys qualitative detail and artifact removal that AbsRel does not measure. The skeptical reading is that its quantitative contribution largely washes out with sufficient training. Both readings are available from the paper’s own table, and the paper does not, in the recoverable text, address the regression.

6.4 Depth parameterization (Table 4)

Average across test sets, common training/eval configuration:

Log depth wins on both metrics. A ~6% AbsRel gain for a change of variables — cheap, and the kind of detail that is easy to get wrong in a reimplementation.

8.1 Using the model

The demo is at hf.co/spaces/huawei-bayerlab/marigold-v2-web.

NOT STATED in the recoverable text: whether code and weights are released, under what license, and at what repository. Check the project page before planning any work that depends on them.

Sketch of what inference looks like, given the formulation in §4.2. Illustrative, not tested — the released API will differ:

# ILLUSTRATIVE — not verified against a released implementation.
import torch

@torch.no_grad()
def predict_depth(image, vae, dit, t=0.5):
    """Single-step affine-invariant log-depth prediction.

    image: float tensor in [-1, 1], shape (B, 3, H, W)
    returns: normalized log-depth in ~[-1, 1], shape (B, 1, H, W)
    """
    z_I = vae.encode(image).latent_dist.mode()

    # One forward pass at a fixed timestep. No iterative denoising.
    v_hat = dit(z_I, timestep=t)

    # Single Euler step of size 1 along the learned velocity field.
    z_d = z_I - v_hat

    d_hat = vae.decode(z_d).sample     # (B, 3, H, W), channels are replicas
    return d_hat.mean(dim=1, keepdim=True)

Recovering metric depth requires inverting the normalization of §4.1, which needs scale and shift you do not have from a single image. That is what the RANSAC alignment in the evaluation protocol supplies:

# ILLUSTRATIVE.
import numpy as np

def to_metric(d_norm, d2, d98, eps=1e-8):
    """Invert the affine-invariant log-depth normalization.

    d2, d98 are the log-depth percentiles — NOT recoverable from the
    prediction alone. In evaluation they come from RANSAC alignment
    against ground truth; in deployment they must come from another
    source (a sparse sensor, known scene scale, or a metric model).
    """
    log_d = (d_norm / 2.0 + 0.5) * (d98 - d2) + d2
    return np.exp(log_d) - eps

This is the deployment caveat that matters. Marigold V2 is affine-invariant. It gives you relative geometry, excellently. It does not give you metres. For robotics or measurement you need a metric anchor — a few LiDAR returns, a known object size, or a separate metric model — and then the two-parameter fit.

8.2 SinkLoss, as a component you might reuse

The block-wise OT loss is the most portable idea in the paper. It applies wherever your labels are spatially noisy at fine scale but distributionally correct: segmentation boundaries, optical flow near occlusions, any sensor-derived dense target.

# ILLUSTRATIVE reference implementation of the formulation in §3.4.
# Hyperparameters follow the paper: K=5, tau=0.1, B=1e6, 5 iterations.
import torch
import torch.nn.functional as F

def sinkhorn_log(log_K, n_iters=5):
    """Sinkhorn-Knopp in the log domain, uniform marginals 1/n."""
    n = log_K.shape[-1]
    log_mu = torch.full(log_K.shape[:-1], -torch.log(torch.tensor(float(n))),
                        device=log_K.device)
    f = torch.zeros_like(log_mu)
    g = torch.zeros_like(log_mu)
    for _ in range(n_iters):
        f = log_mu - torch.logsumexp(log_K + g.unsqueeze(-2), dim=-1)
        g = log_mu - torch.logsumexp(log_K + f.unsqueeze(-1), dim=-2)
    return log_K + f.unsqueeze(-1) + g.unsqueeze(-2)   # log transport plan


def sink_loss(pred, target, mask, K=5, tau=0.1, big=1e6, n_iters=5):
    """pred/target/mask: (B, 1, H, W). mask is 1 for valid pixels."""
    # Tile into non-overlapping K x K blocks -> (B*nblocks, K*K)
    def blocks(x):
        return F.unfold(x, kernel_size=K, stride=K).transpose(1, 2).reshape(-1, K * K)

    p, t, m = blocks(pred), blocks(target), blocks(mask)

    C = (p.unsqueeze(-1) - t.unsqueeze(-2)).abs()        # (N, K^2, K^2)
    valid = (m.unsqueeze(-1) * m.unsqueeze(-2)) > 0.5
    C_tilde = torch.where(valid, C, torch.full_like(C, big))

    log_M = sinkhorn_log(-C_tilde / tau, n_iters=n_iters)
    M = log_M.exp()

    w = M * valid                                        # mask-weighted plan
    num = (w * C).sum(dim=(-2, -1))
    den = w.sum(dim=(-2, -1)).clamp_min(1e-12)

    has_gt = valid.any(dim=(-2, -1))
    return (num / den)[has_gt].mean()

Two things to watch if you adopt this: memory is \(O(N_{blocks} \cdot K^4 \cdot n_{iters})\) once unrolled for autograd — the reason K is small and iterations are few — and the non-overlapping grid means boundaries landing on a tile edge get no tolerance benefit.

8.3 Reproduction checklist

If you are reimplementing, these are the details most likely to cost you a week:

• Log-depth, not linear, not disparity (Table 4 — ~6% AbsRel)
• Percentile clipping at 2/98, over valid pixels only
• Replicate depth across 3 channels so the pretrained VAE is reusable unmodified
• Fixed \(t = 0.5\); do not sample timesteps
• Velocity target \(v = z_I - z_d\), not noise prediction
• \(\lambda_{grad} = 5.0\) — 5× the value losses; this is not a typo
• iREPA target from GT depth, not from RGB
• Filter HyperSim to <0.1% invalid pixels; 90/10 mix with vKITTI
• Freeze the VAE decoder in Stage 1, unfreeze in Stage 2 — SinkLoss needs a trainable decoder to do anything
• Sinkhorn in the log domain; naive exp-space will produce NaNs at \(\tau = 0.1\)
• Gradient clipping — with batch size 1 this is not optional
• Unknown and must come from released code: optimizer, LR, schedule, warmup, EMA, DINOv3 variant, iREPA layer index and projector

What is genuinely strong

The cost story is the contribution. 96 GPU-days → 6 single-GPU-days, with better results, is the kind of result that changes who can do this work. It is also the claim easiest to verify and hardest to argue with.

SinkLoss is a real idea, not a trick. “Your labels are noisy at fine scale, so stop demanding pixel-exact agreement and demand distributional agreement in a small neighborhood instead” is a clean, transferable insight with a principled implementation. It correctly identifies that the metric and the objective were fighting each other, and resolves it in the objective rather than by relabeling.

The iREPA-depth inversion is a good, cheap idea with a clean ablation at 30K steps and no inference cost.

Choosing an image-editing base model rather than a T2I one is an underrated decision that probably contributes more than it gets credit for.

What to hold at arm’s length

The 16–26% framing is the best two of five columns. The median improvement over FE2E is closer to 10%.

iREPA-depth’s contribution at convergence is not established. It regresses two of five datasets at 160K steps. The paper’s quantitative case for it rests on the 30K-step ablation; its case at full training is qualitative (Figure 3).

SEE and SinkLoss are philosophically aligned. Both permit local spatial slack. Winning SEE with an objective built on the same relaxation is weaker evidence than winning a metric that does not share the assumption.

No real-world training data at all. HyperSim + vKITTI are both synthetic. Zero-shot transfer to real benchmarks works, which is the point — but the model has never seen a real depth sensor’s noise, and the benchmark suite may not surface what that costs.

π³ exists. With ~120× the data it is better on several columns. “SOTA at this data scale” is the accurate claim.

Table 2 has two baselines. Defensible (they are the right two) but thin.

Reproducibility is gated on the code release. Optimizer, LR schedule, DINOv3 variant, and iREPA layer are all unstated in the paper, and all of them matter.

Open questions

1. Does SinkLoss transfer to real sensor noise (LiDAR dropout, ToF multipath) rather than only to rendering noise? The motivation generalizes; the evidence does not yet.
2. What does the K-vs-tolerance curve look like? K=5 is asserted, never ablated in the recoverable text.
3. Would overlapping blocks, or a random block-grid offset per step, remove the tile-boundary artifact cheaply?
4. Does the single-step formulation cap achievable detail relative to a few-step variant? The paper does not report a multi-step ablation of its own model.
5. How much of the gain comes from Qwen-Image-Edit specifically versus the losses? There is no base-model ablation.