Transition Matching Distillation for Fast Video Generation

ArXiv: 2601.09881

🎯 Pitch

Instead of treating the video diffusion model as one monolithic network, this work splits it into a deep semantic backbone and a tiny recurrent flow head—and shows that unrolling that head’s inner updates during distillation is the make-or-break factor for compressing generation to under two effective steps while preserving motion coherence.

1. Executive Summary

This paper introduces Transition Matching Distillation (TMD), a framework for distilling large video diffusion models into efficient few-step generators. Working with Wan2.1 1.3B and 14B text-to-video models on the VBench benchmark, TMD decomposes the original diffusion backbone into a main backbone for semantic feature extraction and a lightweight recurrent flow head for iterative refinement—approximating the teacher's many-step denoising trajectory with a compact few-step probability transition process where each outer step contains multiple inner flow updates. This decoupled architecture is trained via a two-stage strategy: transition matching pretraining (using the authors' TM-MF adaptation of MeanFlow to initialize the flow head as a conditional flow map) followed by distribution matching distillation with flow head rollout (applying an improved DMD2-v loss that backpropagates through the unrolled inner flow steps). TMD achieves state-of-the-art speed-quality trade-offs, with the distilled 14B model reaching an overall VBench score of 84.24 in near-one-step generation (effective NFE = 1.38) while outperforming existing distilled models under comparable inference budgets in both visual fidelity and prompt adherence, establishing that hierarchical backbone decomposition with inner-flow recurrence provides effective quality-efficiency control only when the inner steps are unrolled during distillation to close the training-inference gap.

2. Context and Motivation

The Core Problem: Video Diffusion Models Are Too Slow for Interactive Use

The central problem this paper addresses is straightforward but practically urgent: large video diffusion models produce remarkable results but require hundreds of iterative denoising steps, making them far too slow for real-time or interactive applications. The standard sampling process in models like Wan2.1 progressively transforms random noise into coherent video frames through 50 or more forward passes through the full network—each pass involving expensive spatiotemporal attention operations across a high-dimensional latent space (typically 21 frames × 60 × 104 latent resolution at 480p, as detailed in Appendix A). This means generating a single 5-second video clip requires running a multi-billion-parameter transformer 50 times sequentially, which can take minutes on high-end hardware and is entirely impractical for applications demanding sub-second latency.

The paper's opening statement frames this starkly (Section 1):

"Standard diffusion models rely on a multi-step denoising process, often requiring hundreds of iterative steps, to progressively transform noise into realistic outputs. This iterative nature leads to high inference latency and computational cost, rendering large diffusion models impractical for interactive applications such as real-time video generation, content editing, or world modeling for agent training."

This framing matters because it identifies a specific deployment bottleneck that is qualitatively different from the image generation case. Video generation is not simply "image generation with more pixels"—the spatiotemporal dependencies between frames introduce substantially higher dimensionality (the latent tensor for Wan2.1 1.3B is 21 × 60 × 104 = 131,040 elements across time, height, and width, compared to typical image latents of ~4,096 elements) and complex cross-frame coherence requirements. The sampling cost scales poorly with both spatial resolution and temporal length, creating a compounding efficiency problem.

Why This Problem Matters: Three Distinct Motivations

Practical deployment economics. The paper's choice of the Wan2.1 model family is deliberate—these are "open-sourced models" (Section 1) that represent the frontier of publicly available video generation capabilities. If these models cannot be accelerated to few-step inference, their practical utility is severely constrained regardless of output quality. Organizations deploying video generation systems face a direct cost-latency-quality tradeoff: using the full 50-step teacher provides maximum quality but incurs prohibitive inference costs and latency, while naive few-step approximations sacrifice visual fidelity. A principled distillation framework that preserves quality while reducing steps to 1–4 directly expands the deployment envelope—enabling use cases like real-time video editing, interactive content creation tools, and simulation environments for embodied AI training.

The scaling mismatch between training and inference. There is a fundamental asymmetry in how the field allocates computational resources. Training large video diffusion models receives enormous investment—the teacher models were trained on massive datasets with extensive compute budgets. Yet at inference time, the standard practice is to run the identical (expensive) forward pass dozens of times per sample. The paper implicitly argues this is a misallocation: the intelligence learned during training should be extractable in far fewer inference steps if the model's internal representations are properly leveraged. This connects to a broader principle in deep learning—that overparameterized networks learn reusable representations that can be compressed without proportional quality loss.

Video-specific challenges that existing image distillation techniques don't address. The paper argues that simply porting image-domain distillation techniques to video fails because of video's unique properties (Section 1):

"Videos exhibit high spatiotemporal dimensionality and complex inter-frame dependencies, making it difficult to preserve both global motion coherence and fine-grained spatial details during distillation."

This is not just a matter of scale. The trajectory curvature—how non-linear the denoising path is through the high-dimensional space—is substantially larger in video models than in image models. Appendix B.2 quantifies this: the authors define trajectory curvature at each timestep as the deviation between the instantaneous velocity and a straight-line path between noise and data, and show (Figure 12) that Wan trajectories exhibit extremely large curvature near the high-noise regime (t close to 1). This matters because trajectory-based distillation methods (like consistency models and progressive distillation) implicitly assume the ODE trajectory is approximately linear over the segments they skip. When curvature is large, these approaches either fail to learn or require many intermediate supervision points, defeating the purpose of few-step generation.

Prior Approaches and Their Limitations

The paper systematically categorizes existing distillation approaches into two families and identifies specific failure modes for each when applied to video.

Trajectory-Based Distillation: Learning the ODE Path Directly

This family includes Progressive Distillation (Salimans and Ho, 2022), Consistency Models (Song et al., 2023), and their continuous-time extensions like sCM (Lu and Song, 2024) and rCM (Zheng et al., 2025). The core idea is to learn a mapping that jumps directly from a noisy state at time t to a cleaner state at an earlier time, effectively compressing multiple teacher denoising steps into a single student step. The training objective typically regresses the student's prediction against what the teacher would produce after multiple steps—either through explicit teacher rollouts (Progressive Distillation) or through boundary conditions that enforce consistency along the trajectory (Consistency Models).

Why they struggle with video. The paper identifies two interconnected failure modes:

1. Trajectory curvature. As quantified in Figure 12, video diffusion trajectories are highly non-linear, especially in the early denoising stages. Methods that assume approximately straight paths (a reasonable approximation for well-trained image diffusion models) break down when the true path has significant curvature. The student must learn a mapping that "cuts corners" on a winding path, and the regression target becomes ambiguous—multiple valid teacher trajectories may pass through similar noisy states, creating conflicting supervision signals. MeanFlow (Geng et al., 2025), which the paper builds upon extensively, partially addresses this by learning mappings between arbitrary pairs of timesteps rather than only to the data endpoint, but the paper notes that even MeanFlow "is difficult to scale to video generation due to high dimensionality and large trajectory curvature" (Section 2, DMD paragraph).

2. Training instability at scale. Recent work on continuous-time consistency models (Lu and Song, 2024; Zheng et al., 2025) has shown that stabilizing trajectory-based distillation for image models requires careful architectural choices and training procedures. Scaling these to video—with orders of magnitude more parameters and larger latent spaces—magnifies these instabilities. The paper's own experiments with rCM (Tables 1 and 2) show that while rCM achieves strong results (overall score 84.43 for 4-step on Wan2.1 1.3B), the method plateaus or degrades when pushed to very few steps (82.65 for 1-step on Wan2.1 1.3B), suggesting inherent limitations in the approach rather than insufficient tuning.

The paper also notes a specific technical challenge: the Jacobian-vector product (JVP) computation required by MeanFlow-style objectives is "currently incompatible with system optimizations, such as flash attention and FSDP" (Appendix A.2), which are essential for training video models at scale. This forces the use of finite-difference approximations that introduce additional noise and potential instability.

Distribution-Based Distillation: Matching Output Distributions

This family includes adversarial distillation (ADD; Sauer et al., 2024), variational score distillation (VSD; Yin et al., 2024), and distribution matching distillation (DMD2; Yin et al., 2024). Rather than regressing along specific trajectories, these methods train a student generator whose output distribution matches the teacher's distribution—typically using a combination of score-based divergence minimization (matching the score functions of the student and teacher distributions) and adversarial losses (using a discriminator to distinguish student samples from real or teacher-generated samples).

Advantages the paper exploits. Distribution matching methods are intrinsically more tolerant of trajectory curvature because they don't need to follow any specific path—they only need to land in the right region of output space. This makes them more directly applicable to video. However, the paper identifies three specific shortcomings that motivated their DMD2-v improvements (Section 3.2):

1. Discriminator architecture matters enormously. The original DMD2 was designed for image generation and used discriminator heads appropriate for 2D spatial features. Table 3 shows that for video, a Conv3D discriminator (which jointly processes spatiotemporal features) achieves an overall VBench score of 83.24 compared to 82.36 for attention-based discriminators and 81.63 when the GAN loss is removed entirely. The paper's explanation—"implying the importance of localized, spatio-temporal features for the GAN loss"—highlights that video requires discriminators that can evaluate temporal coherence, not just per-frame quality.

2. Knowledge distillation warm-up is double-edged. Using the teacher to generate noise-data pairs for initializing the student (KD warm-up) helps one-step distillation (83.24 vs. 83.06 without it, Table 4) but hurts multi-step distillation (83.79 vs. 84.39 two-step, Table 4). The paper shows qualitative evidence in Figure 10: KD warm-up "introduces coarse-grained artifacts that can be hardly fixed by the DMD2 training" in multi-step settings, likely because the warm-up over-constrains the student's early representations in ways that limit the flexibility needed for multi-step refinement.

3. Timestep sampling is critical and under-explored. Table 5 reveals that applying a shifting function to the timesteps used in the DMD loss (t_dmd) prevents severe mode collapse (shown qualitatively in Figure 9, where all generated characters consistently appear on the left side of the frame). Without timestep shifting, the VBench score remains similar (83.22 vs. 83.24) but the generated videos exhibit catastrophic distributional collapse—a failure mode that standard metrics don't capture. This is a non-obvious finding: the metric says performance is similar, but the actual output quality is qualitatively broken, underscoring why careful ablation beyond aggregate scores is essential.

The Fundamental Architectural Limitation: Monolithic Treatment of the Diffusion Backbone

Beyond the trajectory-vs-distribution dichotomy, the paper identifies a deeper limitation shared by nearly all prior distillation approaches:

"Most existing methods treat the diffusion network as a monolithic mapping, neglecting the hierarchical structure and semantic progression inherent in large video diffusion backbones" (Section 1).

This is the key conceptual insight that motivates TMD's decoupled architecture. Large diffusion transformers—the Wan2.1 models have 30 (1.3B) or 40 (14B) DiT blocks—process information hierarchically. Early layers extract high-level semantic features (object identities, scene layout, motion patterns), while later layers refine these into fine-grained visual details (textures, edges, precise motion trajectories). Treating the entire network as a single black-box mapping throws away this structure: during distillation, every layer must be updated to handle both semantic understanding and detail refinement simultaneously, typically over a much smaller number of steps than it was trained for.

The paper's key architectural argument is that this monolithic treatment is wasteful because:

• Semantic features evolve slowly across denoising steps—once the model knows "this is a rabbit in a purple robe in a fantasy landscape" (Figure 1), that semantic understanding remains largely stable.
• Visual details require iterative refinement—getting the fur texture, robe folds, and lighting right benefits from multiple refinement passes conditioned on the stable semantic representation.

By decoupling these functions, TMD can reuse expensive semantic computations across multiple refinement steps, trading off the cost of additional lightweight flow head passes against the quality gains they provide.

How This Paper Positions Itself

TMD synthesizes ideas from three distinct research threads in a way that is specifically engineered for video:

From Transition Matching (Shaul et al., 2025). The paper adopts TM's framework of modeling probabilistic transitions between widely separated noise levels as conditional flows, where an auxiliary latent variable y (specifically y = x₁ - x, the DTM formulation) bridges the gap. However, the paper extends TM in two critical directions: (1) scaling it from image generation to video, which requires addressing the spatiotemporal dimensionality and trajectory curvature issues, and (2) using it for distillation rather than training from scratch—meaning the student starts from a pretrained teacher's weights rather than random initialization.

From MeanFlow (Geng et al., 2025). The paper adopts MeanFlow's insight that learning flow maps between arbitrary timestep pairs (rather than only to the data endpoint) enables more flexible few-step generation. The TM-MF pretraining objective in Stage 1 directly builds on MeanFlow's average velocity parameterization and JVP-based training objective. However, the paper makes specific adaptations for the video distillation setting: using a finite-difference JVP approximation to maintain compatibility with flash attention and FSDP (Appendix A.2), parameterizing the average velocity to stay aligned with the teacher's velocity prediction (Eq. 14), and conditioning the flow head on the main backbone's features through a gated fusion mechanism.

From DMD2 (Yin et al., 2024). The paper adopts DMD2's distribution matching framework with its combination of VSD loss and GAN discriminator for Stage 2 distillation. The DMD2-v improvements (Conv3D discriminator, selective KD warm-up, timestep shifting) represent the paper's careful engineering to make distribution matching work reliably for video—addressing stability issues that are largely absent in the image domain.

What makes TMD distinctive is the combination of these elements with the decoupled architecture and, critically, the flow head rollout during distillation. The paper's own ablation (Figure 7) demonstrates that without unrolling the inner flow steps during training—i.e., training the flow head independently and only using multiple steps at inference—convergence is slower and final performance is worse. This is because unrolling closes the train-test gap: during inference, the flow head's output from step j becomes the input to step j+1, so errors compound. Training with rollout exposes the flow head to this compounding effect and forces it to learn correction strategies.

The paper explicitly positions itself as addressing the "flexible trade-off between generation speed and visual quality" (Section 1) that is missing from existing methods. The effective NFE metric (Eq. 16)—which accounts for the fraction of DiT blocks used in the flow head and the number of inner steps—provides a continuous knob: TMD-N2H5 with effective NFE = 2.33 and TMD-N4H5 with effective NFE = 3.00 both achieve ~84.67 overall score on Wan2.1 1.3B (Table 1), but one uses fewer effective forward passes. This fine-grained control, enabled by the decoupled architecture, is unavailable to monolithic distillation methods where the only knob is the discrete number of denoising steps M.

Summary of the Motivation Landscape

The paper addresses a clear deployment bottleneck (video diffusion model sampling speed) that existing distillation approaches fail to solve adequately because they (1) assume approximately linear ODE trajectories that don't hold for video, (2) ignore the hierarchical structure of diffusion transformer backbones, and (3) use architectures and training procedures optimized for images that don't transfer cleanly to the spatiotemporal domain. TMD's decoupled backbone with recurrent flow head, combined with trajectory-based pretraining followed by distribution matching distillation with flow head rollout, is positioned as a synthesis that addresses all three limitations simultaneously. The paper's extensive ablation studies (Section 4.3, Appendix B) are designed to demonstrate that each component—the decoupled architecture, the TM-MF pretraining, the DMD2-v improvements, and the flow head rollout—contributes meaningfully to the final performance, supporting the claim that this synthesis is genuinely novel rather than an incremental combination of existing techniques.

3. Technical Approach

3.1 Reader Orientation

TMD is a two-stage training system that takes a pretrained, slow (50-step) video diffusion model and produces a fast (1–4 step) student generator capable of producing comparable-quality videos. The system solves the problem that directly applying existing image distillation methods to video fails because video has higher dimensionality, more complex spatiotemporal dependencies, and substantially more curved denoising trajectories—so TMD introduces a decoupled architecture that separates semantic feature extraction (expensive, done once per outer step) from visual detail refinement (cheap, done multiple times per outer step), then trains this architecture first to learn the correct flow dynamics (Stage 1: trajectory-based pretraining) and then to match the teacher's output distribution (Stage 2: distribution-based distillation with inner-step unrolling).

3.2 Big-Picture Architecture (Diagram in Words)

The TMD system has five major components connected in a two-stage training pipeline:

1. Teacher Video Diffusion Model (Wan2.1) — a pretrained 30-block (1.3B) or 40-block (14B) DiT that performs 50-step denoising from noise to video. It serves as both the source of pretrained weights and the quality target for distillation.

2. Main Backbone (student) — the first L - H DiT blocks of the teacher (e.g., the first 25 of 30 blocks for Wan2.1 1.3B with H=5), frozen or fine-tuned to extract semantic features m_t from the noisy input x_t at each outer transition step.

3. Flow Head (student) — the last H DiT blocks of the teacher (e.g., blocks 26–30), converted into a recurrent module that takes the main backbone's features m_t, a noisy inner-flow sample y_s, and inner timesteps (s, r) as input, and predicts the target y through N sequential refinement steps using a conditional flow map.

4. Fusion Layer — a lightweight gating mechanism that combines the main backbone's semantic features m_t with the flow head's tokenized inner-flow input, ensuring the student's initial forward pass matches the teacher's while allowing the flow head to condition on the pre-extracted semantics.

5. Two-Stage Training Pipeline — Stage 1 uses the TM-MF (Transition Matching MeanFlow) objective to pretrain the flow head as a conditional flow map capable of iterative refinement; Stage 2 uses the DMD2-v objective (improved distribution matching distillation for video) with flow head rollout, where gradients from the VSD and GAN losses backpropagate through all N unrolled inner-flow steps.

Information flows as follows: a text prompt and noise sample enter → the main backbone processes the noisy latent x_t at outer timestep t_i to produce feature map m_t → the fusion layer combines m_t with the inner-flow noisy state y_s → the flow head iteratively refines y_s through N steps (each step: y_{s_{j-1}} = f_θ(y_{s_j}, s_j, s_{j-1}; m_t)) to produce the clean target y → the outer transition step uses y to jump from x_{t_i} to x_{t_{i-1}} via the DTM formula x_{t_{i-1}} = x_{t_i} - (t_i - t_{i-1}) y. This outer-inner loop repeats for M transition steps to generate the final video.

3.3 Roadmap for the Deep Dive

• First, the decoupled architecture — how the teacher is split into main backbone and flow head, what the flow head target y represents, and how the fusion layer works — because every subsequent training and inference step depends on this decomposition.
• Second, the TM-MF pretraining objective (Stage 1) — how MeanFlow's flow map learning is adapted to the video setting, why the average velocity is parameterized to stay aligned with the teacher, and how the JVP is approximated — because this establishes the flow head's ability to perform iterative refinement before distillation.
• Third, the DMD2-v improvements (Stage 2 baseline) — the three modifications to standard DMD2 for video (Conv3D discriminator, selective KD warm-up, timestep shifting) — because TMD's Stage 2 builds directly on these, and understanding them clarifies what TMD adds beyond improved DMD2.
• Fourth, the flow head rollout mechanism — how the inner flow steps are unrolled during distillation, how gradients flow through the chain, and why this closes the training-inference gap — because this is the critical innovation that makes the decoupled architecture work for few-step generation.
• Fifth, the complete TMD algorithm — how Stage 1 and Stage 2 fit together, the pseudocode (Algorithm 2), the inference procedure (Algorithm 1), and the effective NFE metric — to show the end-to-end system.
• Sixth, design choice justifications — why DTM formulation for y, why the gated fusion over concatenation, why MeanFlow over vanilla flow matching for pretraining, why distribution matching over trajectory matching for Stage 2, and why the two-stage approach over end-to-end training.

3.4 Detailed, Sentence-Based Technical Breakdown

This is an architectural and training methodology paper whose core idea is that video diffusion models can be efficiently distilled into few-step generators by decomposing the backbone into a semantic feature extractor and a recurrent refinement head, then training this decoupled architecture with a two-stage strategy where trajectory-based pretraining teaches the head to refine and distribution-based distillation with head unrolling aligns the output distribution with the teacher.

Decoupled Architecture: Splitting the Teacher into Main Backbone and Flow Head

The teacher model is a standard diffusion transformer (DiT) with L blocks (L=30 for Wan2.1 1.3B, L=40 for Wan2.1 14B) that takes a noisy latent x_t at timestep t, text conditioning c, and predicts the instantaneous velocity v(x_t, t) under the rectified flow schedule. The paper's first architectural decision is to split this monolithic stack into two components at block index L - H + 1, where H is a hyperparameter controlling how many final blocks become the flow head (experiments use H=2, 3, 5, or 8 out of L=30).

Main backbone (m_θ). The first L - H DiT blocks, initialized from the teacher's pretrained weights. Given the noisy latent x_{t_i}, the outer timestep t_i, and text conditioning c, the main backbone produces a feature map m_t = m_θ(x_{t_i}, t_i) at the same spatial resolution as its input. This feature map represents the high-level semantic understanding of the scene—object identities, rough spatial layout, motion patterns—extracted from the noisy input. The key insight is that this semantic representation is relatively stable across outer transition steps: once the model determines "this is a rabbit in a purple robe," that understanding remains valid for the remainder of generation, so recomputing it from scratch in every inner refinement step would be wasteful.

Flow head (f_θ). The final H DiT blocks, also initialized from the teacher but repurposed for a different task. Instead of predicting the outer velocity v(x_t, t), the flow head performs inner-flow refinement: it takes as input a noisy version y_s of the target variable y (to be defined below), inner timesteps s and r (where r ≤ s), and the main backbone's features m_t as conditioning, and predicts a less noisy version y_r. When executed for N sequential steps starting from s_N = 1 (pure noise) down to s_0 = 0 (clean target), the flow head iteratively denoises y conditioned on the semantic context m_t.

Flow head target y (the DTM formulation). The paper defines the auxiliary latent variable that the flow head predicts as:

$y := x_1 - x$

where x_1 ~ N(0, I) is the initial noise and x is the clean data (in latent space). This is the Difference Transition Matching (DTM) formulation from Shaul et al. (2025).

What it represents: y is the vector difference between the initial noise and the clean data—essentially the "direction and magnitude" of the denoising trajectory. Given y and the current noisy state x_{t_i}, the next state x_{t_{i-1}} can be computed deterministically as:

$x_{t_{i-1}} = x_{t_i} - (t_i - t_{i-1}) y$

Why this form: The DTM formulation has a crucial property: y is the negative of the conditional expectation E[x_1 - x | x] that the teacher's velocity prediction approximates. This means y is semantically aligned with what the pretrained teacher already knows how to predict—the teacher was trained to output v(x_t, t) ≈ E[x_1 - x | x_t]. By choosing y = x_1 - x as the flow head target, the paper ensures that the flow head's output space matches the teacher's original output space, making it easier to initialize from pretrained weights and maintain alignment during training. In contrast, alternative targets like y := x (predicting the clean sample directly) are also valid mathematically but require the flow head to learn a different mapping than what the pretrained weights encode, which the paper shows leads to worse performance (Appendix B.4, Table 10: DTM x_1 - x achieves 84.68 overall vs. 84.18 for x target in the N2H5 setting).

Flow head inner-flow schedule. Within each outer transition step, the flow head runs an inner rectified flow from s = 1 (pure noise y_1 ~ N(0, I)) to s = 0 (clean prediction y_0), using a discretized time grid 0 = s_0 < s_1 < ... < s_N = 1. At each inner step j, the flow head predicts:

$y_{s_{j-1}} \approx f_\theta(y_{s_j}, s_j, s_{j-1}; m_t)$

where m_t = m_θ(x_{t_i}, t_i) is the frozen (or fine-tuned) semantic feature from the main backbone.

What this computes: Starting from random noise y_1, the flow head progressively denoises it through N steps, each time using the main backbone's semantic features as conditioning. After N steps, the output y_0 is the flow head's best estimate of x_1 - x given the semantic context. Then x is recovered as x = x_1 - y_0, and the outer transition uses this x (implicitly, through y_0) to update x_{t_{i-1}}.

Why this form: The inner flow provides a flexible compute-quality tradeoff. With N = 1, the flow head makes a single prediction—fastest but potentially inaccurate. With N > 1, the flow head has multiple opportunities to refine its prediction, each step conditioning on the previous step's output and the stable semantic features. The cost of additional inner steps is modest because the flow head has only H DiT blocks (vs. L for the full backbone), and the main backbone runs only once per outer transition regardless of N.

Fusion layer. The key architectural challenge in the decoupled design is how to combine the main backbone's features m_t with the flow head's input y_s. A naive approach—simply concatenating them and passing through a linear projection—would disrupt the pretrained weights because the flow head expects a specific input distribution. The paper uses a gated fusion mechanism (Figure 8a, Appendix A.1) with three steps:

1. The inner-flow input y_s is first passed through the teacher's patch embedding layer (shared with the main backbone) to produce token embeddings.
2. These token embeddings are processed through a randomly initialized AdaLN-style block (adaptive layer normalization, MLP, gated residual connection) conditioned on the embedding of the inner timestep s. This block is specifically designed to match the architectural pattern of the teacher's DiT blocks, making it compatible with the pretrained flow head.
3. The processed flow head tokens are fused with the main backbone's feature map m_t using a gated interpolation controlled by a learnable scalar parameter passed through a sigmoid activation. This gate dynamically weights the contribution of the flow head's input against the backbone's features at the feature level before the final combination.

Why gated fusion over alternatives: The paper compares gated fusion against concatenation fusion (Figure 8b, where m_t and y_s tokens are concatenated channel-wise and projected). Both achieve similar final performance (Table 9: 84.68 for gated vs. 84.76 for concat in N2H5), but the gated mechanism provides more stable training convergence (Figure 13). The gating ensures that at initialization (when the learned gate parameter is near zero), the flow head sees essentially the same input distribution as the original teacher, preventing the pretrained weights from being disrupted. As training progresses, the gate opens to allow the flow head to leverage the backbone's features.

Weight sharing. The flow head reuses the teacher's patch embedding layer (for tokenizing y_s) and the teacher's time embedding for the inner timestep s. Additionally, the flow head instantiates a separate, zero-initialized time embedding for the timestep difference s - r, which is summed with the s embedding to condition the adaptive normalization layers. This zero-initialization means that at the start of training, the flow head's behavior depends only on s, matching the teacher's original behavior, and gradually learns to use the s - r information to handle variable-length jumps.

Stage 1: Transition Matching MeanFlow (TM-MF) Pretraining

The goal of Stage 1 is to convert the flow head from a standard DiT block (which predicts instantaneous velocity at a single timestep) into a flow map—a function that can jump directly from any inner timestep s to any earlier timestep r in a single forward pass. This capability is essential for few-step generation: if the flow head can only make small steps (as in standard flow matching), it would need many inner steps to produce an accurate y, defeating the purpose of the decoupled architecture.

Flow maps via average velocity. The paper parameterizes the conditional inner flow map using an average velocity formulation (following MeanFlow, Geng et al., 2025):

$f_\theta(y_s, s, r; m) := y_s + (s - r) u_\theta(y_s, s, r; m)$

where u_θ is a neural network that predicts the average velocity along the trajectory segment from y_s to y_r, and m = m_θ(x_{t_i}, t_i) is the main backbone feature.

What it computes: Given a noisy state y_s at timestep s, the flow map predicts the state y_r at an earlier timestep r by moving along the direction u_θ for a distance (s - r). When r = s, this reduces to f_θ(y_s, s, s; m) = y_s (no movement). When r < s, the flow map extrapolates the trajectory over a non-infinitesimal interval, enabling large jumps.

Why this form: Directly predicting y_r from y_s would require learning a mapping that depends on both s and r in a complex, non-linear way. The average velocity parameterization decomposes this into: (1) predict a direction u_θ, and (2) move along it proportionally to the timestep difference. This inductive bias—that the trajectory is approximately linear over the interval [r, s] in the velocity space—is much easier to learn than an arbitrary mapping, especially when (s - r) is small relative to the trajectory curvature. For the large jumps needed in few-step generation, the quality of the average velocity prediction becomes the critical factor.

Alignment with teacher velocity. A crucial design choice is how to parameterize u_θ to stay aligned with the pretrained teacher. Since the teacher was trained to predict E[x_1 - x | x_t] (the instantaneous velocity of the outer flow), the paper wants the flow head's output to remain close to this prediction to avoid disrupting pretrained knowledge. From the inner velocity definition (Eq. 5–6), they observe:

$u_\theta(y_s, s, s; m) \approx \mathbb{E}[y_1 - (x_1 - x) | y, x_t]$

This means that at r = s, the average velocity should predict the difference between the inner-flow noise y_1 and the DTM target y = x_1 - x. To enforce this, the paper parameterizes the average velocity as:

$u_\theta(y_s, s, r; m) := y_1 - \text{head}_\theta(y_s, s, r; m)$

where head_θ is the flow head network (initialized from the teacher's final H blocks).

What this achieves: In the limit r → s, the flow head output head_θ(y_s, s, s; m) approximates the teacher's velocity prediction E[x_1 - x | ...]. This means the flow head can leverage its pretrained knowledge immediately—at r = s, it produces output very close to what the original teacher would produce. For r < s, the (s - r) u_θ term in the flow map provides the correction needed for the larger jump. This parameterization essentially says: "start from what the teacher knows (predicting x_1 - x), and adjust the prediction to account for the fact that we're jumping over a larger interval."

Comparison with alternative parameterization: Without this alignment, the flow head would need to learn the average velocity from scratch, losing the benefit of pretrained weights. The paper confirms this empirically: Appendix B.4 shows that using the simple y := x target (where the flow head predicts the clean sample directly) achieves worse performance (84.18 vs. 84.68 overall for N2H5), because the flow head's output space doesn't match what the pretrained weights encode.

The MeanFlow training objective for TM-MF. The paper adapts MeanFlow's training objective (Eq. 9–10 from Geng et al., 2025) to the conditional setting:

$\mathcal{L}(\theta) := \mathbb{E}_{s, r, y_s}\left[ \| u_\theta(y_s, s, r) - \hat{u} \|^2 \right]$

with the target constructed via stop-gradient:

$\hat{u} := \text{sg}\left( v(y_s, s) - (s - r) \frac{d}{ds} u_\theta(y_s, s, r) \right)$

where sg(·) is the stop-gradient operator, v(y_s, s) is the conditional (inner-flow) velocity v(y_s, s) = y_1 - y (Eq. 6), and d/ds u_θ is the total derivative of the average velocity with respect to the inner timestep.

What it computes: This objective trains u_θ to predict the average velocity without requiring ground-truth average velocities (which are unavailable). The key insight (Eq. 8 in the paper) is that the instantaneous velocity v(y_s, s) and the average velocity u(y_s, s, r) are related by:

$u(y_s, s, r) + (s - r) \frac{d}{ds} u(y_s, s, r) = v(y_s, s)$

This is derived by differentiating the flow map equation f(y_s, s, r) = y_s + (s - r) u(y_s, s, r) with respect to s and equating to the instantaneous velocity. Rearranging:

$u(y_s, s, r) = v(y_s, s) - (s - r) \frac{d}{ds} u(y_s, s, r)$

The training objective uses this identity as a self-consistency target: the average velocity u_θ should satisfy this relationship with the (easily computed) conditional velocity v = y_1 - y. The stop-gradient on the right-hand side prevents the target from depending on u_θ through v, turning this into a regression problem where the network's own derivative provides the correction term.

Why this form is necessary: Standard flow matching would train the flow head to predict v(y_s, s) = y_1 - y, which is only valid for infinitesimal steps (r → s). To handle finite jumps (r < s), the model needs to know not just the current velocity but how the velocity changes along the trajectory—this is precisely what the d/ds u_θ term captures. The MeanFlow objective bootstraps this knowledge: it trains u_θ to be self-consistent with its own derivative, using the easily-available conditional velocity as a anchor. This avoids the need for simulating the full inner-flow trajectory during training (which would be computationally prohibitive) while still teaching the flow head to handle variable-sized jumps.

Finite-difference JVP approximation. Computing d/ds u_θ(y_s, s, r) requires a Jacobian-vector product (JVP) through the flow head network. The paper notes that forward-mode automatic differentiation for JVP computation is "currently incompatible with system optimizations, such as flash attention and FSDP" (Appendix A.2), which are essential for training video models at scale due to memory constraints. Instead, they use a central finite-difference approximation:

$\frac{d}{ds} u_\theta(y_s, s, r) \approx \frac{u_\theta(y_{s+\delta}, s+\delta, r) - u_\theta(y_{s-\delta}, s-\delta, r)}{2\delta}$

with y_{s±δ} = y_s ± δ · v(y_s, s), where δ = 0.005 and v(y_s, s) = y_1 - y is the conditional velocity.

What this computes: It approximates the derivative by evaluating u_θ at two nearby points along the inner-flow trajectory (one slightly forward, one slightly backward) and computing the finite difference. The perturbation δ · v(y_s, s) moves y_s along the flow direction to stay on the trajectory.

Why this approach: The finite-difference approximation is agnostic to the underlying architecture and training infrastructure—it requires only standard forward passes through the network, making it compatible with flash attention, FSDP, and context parallelism. The cost is two additional forward passes per training sample (one for y_{s+δ}, one for y_{s-δ}) and approximation error from the finite δ. The authors set δ = 0.005 empirically as a balance between accuracy (smaller δ is more accurate) and numerical stability (very small δ amplifies floating-point errors). At the boundaries where s ± δ would exceed [0, 1], they fall back to one-sided differences.

Training recipe details for TM-MF (Appendix A.2). Several practical choices stabilize the pretraining:

• Discrete timestep sampling. Rather than sampling s and r continuously from [0, 1], the paper uses a discrete grid for s (the same grid used in Stage 2: 0 = s_0 < s_1 < ... < s_N = 1, with timestep shifting γ = 10 applied) and samples s_mf uniformly with an additional shift (γ = 3). Then r is set to the largest grid point s_k such that s_k ≤ s_mf. This discretization aligns TM-MF pretraining with the discrete-step inference used in Stage 2, avoiding a train-test mismatch in the timestep distribution.

• Flow matching stabilization. For 75% of training batches, r is set equal to s (s - r = 0), reducing the MeanFlow objective to standard flow matching. This stabilizes early training by providing a simple, well-behaved target before introducing the more complex finite-jump objective.

• Classifier-free guidance (CFG). The conditional velocity v(y_s, s) is computed with CFG using a guidance scale of 3, and the text condition is dropped with probability 0.1 during training (using a negative prompt specified in Table 8). This ensures the flow head learns to handle both conditional and unconditional generation, matching standard inference practices.

• Adaptive loss normalization. To handle the varying scale of the prediction error across timesteps and samples, the final loss divides the squared error by its own exponentially moving average plus a constant c:

$\mathcal{L}_{\text{final}} = \mathbb{E}_{s, r, y_s} \left[ \frac{\|u_\theta(y_s, s, r) - \hat{u}\|^2}{\text{sg}(\|u_\theta(y_s, s, r) - \hat{u}\|^2) + c} \right]$

where c = d for Wan2.1 1.3B and c = d/10^5 for Wan2.1 14B, with d being the latent dimension. This prevents the loss from being dominated by large errors at the beginning of training while still providing meaningful gradients.

• Hyperparameters: AdamW optimizer with learning rate 3 × 10^{-5} (1.3B) or 1 × 10^{-5} (14B), global batch size 64, 3,000 iterations maximum, BF16 precision with timesteps in FP64.

Stage 2: DMD2-v — Improved Distribution Matching Distillation for Video

The second stage uses distribution matching to align the student's few-step output distribution with the teacher's multi-step output distribution. The paper first develops DMD2-v, an improved version of DMD2 (Yin et al., 2024) specifically tuned for video, then uses it as the Stage 2 loss for TMD.

Why distribution matching rather than trajectory matching for Stage 2. The paper argues (Section 2, DMD paragraph) that trajectory-based methods like MeanFlow "is difficult to scale to video generation due to high dimensionality and large trajectory curvature." Distribution matching methods like DMD2 avoid this by not requiring the student to follow any specific denoising path—they only need the student's final output distribution to match the teacher's. This is especially important for video where, as quantified in Figure 12, the denoising trajectories have extremely large curvature near t = 1, making it difficult for trajectory-based methods to learn accurate large-jump mappings.

The VSD (Variational Score Distillation) objective. The core of DMD2 is the VSD loss, which minimizes the reverse KL divergence between the student and teacher distributions:

$\mathcal{L}(\theta) = \mathbb{E}_{t_i, x_{t_i}, t, \hat{x}_t} \left[ w(t) \cdot \text{sg}\left( D(\hat{x}_t, t) \right)^T \hat{x} \right]$

where t_i is an outer transition timestep (sampled from the student's discretization {t_1, ..., t_M}), x_{t_i} is the noisy input at that timestep, \hat{x} = g_θ(x_{t_i}, t_i) is the student's output, t is a noise level for the VSD loss (sampled uniformly with timestep shifting), \hat{x}_t = (1 - t)\hat{x} + t x_1 is a noisy version of the student's output, w(t) is a time-dependent weighting, and D(\hat{x}_t, t) is the difference between the scores of the student and teacher distributions evaluated at the noisy sample.

What it computes: The VSD loss provides a gradient signal that pushes the student's output distribution toward the teacher's distribution. The score difference D acts as a critic: when the student's samples are in regions where the teacher assigns high probability (low teacher score) but the student assigns low probability (high fake score), D points toward the teacher's high-probability region. The expectation over t_i, x_{t_i}, t, and \hat{x}_t ensures the student learns to map from all noise levels and produces outputs that match the teacher across the full noise schedule.

Why stop-gradient is critical: The score difference D is computed using a separately trained "fake score" network that estimates the score of the student's (changing) distribution. Without stop-gradient, the loss would try to simultaneously move the student's samples and update the score estimate, creating a moving-target problem. The stop-gradient treats D as a fixed direction for the current update, with the fake score updated separately in between student updates.

The three DMD2-v improvements. The paper identifies and addresses three failure modes when applying DMD2 to video:

1. Conv3D discriminator (Table 3). Standard DMD2 uses a discriminator that operates on intermediate features of the fake score or teacher network. The paper compares three discriminator architectures:

• Conv3D: jointly processes spatiotemporal features with 3D convolutions → overall score 83.24
• Conv1D-2D: separates temporal (1D) and spatial (2D) convolutions, similar to SF-V (Zhang et al., 2024) → 82.32
• Attention: flattens spatiotemporal features into tokens processed by self-attention (with pooling downsampling) → 82.36
• No GAN (VSD only): → 81.63

The Conv3D advantage (approximately +0.9 overall vs. the next best) demonstrates that evaluating video quality requires spatiotemporal locality—the discriminator needs to detect artifacts that span both space and time (e.g., flickering textures, inconsistent motion), which separable or attention-based architectures process less effectively. The discriminator uses 68M parameters for the 1.3B model and 172M for the 14B model, operates on teacher features at specific DiT block layers (15, 22, 29) for 1.3B and (19, 29, 39) for 14B (selected to capture features at multiple semantic levels), and is trained with average minimax log-likelihood across separate heads per feature level.

2. Selective KD warm-up (Table 4). Knowledge distillation warm-up initializes the student by training it on teacher-generated noise-data pairs (x_{t_i} → x) for 10,000 trajectories using a CFG scale of 5. For one-step generation:

• With KD warm-up: overall 83.24
• Without KD warm-up: overall 83.06

KD warm-up helps by providing a good initialization that approximately matches the teacher's single-step prediction. For two-step generation:

• With KD warm-up: overall 83.79
• Without KD warm-up: overall 84.39

KD warm-up hurts multi-step because it "introduces coarse-grained artifacts that can be hardly fixed by the DMD2 training" (Section 3.2). Figure 10 shows qualitative evidence: the KD-warmup model initially generates an extra person (not specified in the prompt) alongside the intended couple, and after 1,000 DMD2 iterations, this artifact persists. The paper hypothesizes that KD warm-up over-constrains the student's early representations, limiting the flexibility needed for the multi-step refinement process to correct errors. Consequently, TMD applies KD warm-up only for one-step (M = 1) distillation and skips it for multi-step.

3. Timestep shifting (Table 5, Figure 9). The paper applies a shifting function to two different timesteps:

For t_dmd (the noise level in the VSD loss, controlling how much noise is added to the student's output before passing to the score networks):

$t = \frac{\gamma t'}{(\gamma - 1) t' + 1}$

where t' ~ Uniform(0, 1) and γ = 5 for one-step generation. Without this shifting, t is sampled uniformly.

For t_student (the outer transition timesteps defining the student's denoising schedule):

$t_i = \frac{10 t_i'}{9 t_i' + 1}$

where t_i' are uniformly spaced in [0, 1] and γ = 10 for multi-step generation.

What shifting does: The shifting function concentrates more timesteps near t = 1 (the high-noise regime) and fewer near t = 0 (the low-noise regime). For γ = 10, the first half of the uniform grid [0, 0.5] maps to only about 9% of the shifted range, while the second half [0.5, 1.0] maps to 91%—a dramatic redistribution toward high noise.

Why shifting is necessary: The paper's trajectory curvature analysis (Figure 12) shows that the Wan model's denoising trajectory has much larger curvature near t = 1 than near t = 0. By concentrating student steps and VSD supervision in the high-curvature regime, the model gets more training signal where the mapping is hardest to learn. Table 5 shows: without t_dmd shifting in one-step generation, the overall score drops only slightly (83.22 vs. 83.24), but the generated videos exhibit severe mode collapse—Figure 9 shows all generated characters consistently appearing on the left side of the frame, indicating the model has failed to learn the full distribution. This is a case where aggregate metrics fail to capture catastrophic qualitative degradation, making the timestep shifting a critical (and easily overlooked) design choice. For multi-step generation, t_student shifting improves overall score from 83.44 to 84.39, a much more visible metric improvement.

Fake score training. The fake score network estimates the score of the student's distribution and is required for computing D in the VSD loss. It is initialized from the teacher parameters, parameterized analogously to the student as g_fake(x_t, t) = x_t - t v_fake(x_t, t), and trained using denoising score matching on noisy fake data (\hat{x}_t, t)—the same noisy samples used in the VSD loss. Both the discriminator and fake score are updated for several iterations between student updates (the student is updated every 5th iteration), with learning rates 10^{-5} for all three networks.

Complete DMD2-v loss. The VSD objective in DMD2-v is implemented as (Appendix A.3):

$\mathcal{L}_{\text{VSD}} = \mathbb{E}_{t_i, x_{t_i}, t, \hat{x}_t} \left[ \text{sg}\left( \frac{g_{\text{fake}}(\hat{x}_t, t) - g_{\text{teacher}}(\hat{x}_t, t)}{\|g_{\text{fake}}(\hat{x}_t, t) - g_{\text{teacher}}(\hat{x}_t, t)\|_1} \right)^T \hat{x} \right]$

where both g_fake and g_teacher include CFG with scale 5 using the negative prompt in Table 8, and the difference is L1-normalized for stability. The total Stage 2 loss adds a GAN discriminator term:

$\mathcal{L}_{\text{total}} = \mathcal{L}_{\text{VSD}} + \lambda \cdot \mathcal{L}_{\text{GAN}}$

with λ = 0.03. The GAN loss uses a non-saturating formulation for the generator and an average minimax log-likelihood for the discriminator.

Flow Head Rollout: Closing the Training-Inference Gap

The critical innovation that distinguishes TMD from simply running DMD2-v on a decoupled architecture is flow head rollout during Stage 2 training. Without rollout, the flow head would be trained independently—given a noisy y_s, it predicts y_r, and the loss penalizes prediction error for that single step. At inference time, however, the flow head runs sequentially: its output from step j becomes the input to step j+1. Errors compound across steps, and the flow head was never trained to handle its own (potentially imperfect) outputs as inputs.

How rollout works. During Stage 2 training, instead of treating the flow head as making a single prediction, the paper unrolls the full inner-flow trajectory of N steps and treats the resulting end-to-end function as the sample generator:

$g_\theta(x_{t_i}, t_i; y_1) := x_1 - \text{InnerFlow}(m_\theta(x_{t_i}, t_i))$

where InnerFlow(m) executes the iterative refinement (Algorithm 1):

def InnerFlow(m):
    y ~ N(0, I)                          # y_1: initial noise
    for j = N down to 1:                 # from s_N=1 to s_0=0
        y = f_θ(y, s_j, s_{j-1}; m)     # flow head prediction
    return y                             # final estimate of x_1 - x

What this computes: The VSD and GAN losses are applied to the final output g_θ(x_{t_i}, t_i; y_1) after all N inner-flow steps. Gradients from these losses backpropagate through the entire chain of N flow head calls, the fusion layer, and into the main backbone (if it is being fine-tuned). This means the flow head is trained to produce outputs that, when fed back into itself for subsequent steps, lead to a good final result—it learns to correct its own errors because training exposes it to the compounding effect.

Computational cost of rollout. The paper acknowledges that unrolling adds computational overhead during training but argues it is manageable because the flow head is lightweight. Specifically: if the flow head has H DiT blocks out of L total blocks, unrolling N steps adds N × H/L equivalent forward passes per outer transition. For the N4H5 setting on Wan2.1 1.3B (L=30, H=5, N=4), this adds 4 × 5/30 ≈ 0.67 equivalent forward passes—less than 17% extra computation relative to the main backbone's forward pass. The main backbone runs only once per outer transition regardless of N, so the additional cost scales favorably.

Why rollout matters (Figure 7). The paper's ablation comparing TMD with and without flow head rollout shows:

• With rollout: faster convergence (higher overall VBench score at each training iteration) and better final performance.
• Without rollout: slower convergence and lower final performance.

The gap exists because without rollout, the flow head sees only "clean" intermediate states during training (sampled from the true inner-flow distribution) but encounters its own imperfect predictions during inference. This distribution shift—the flow head's output distribution differs from the true y_s distribution it was trained on—causes error accumulation that the model never learned to handle. Rollout eliminates this shift by training on exactly the distribution the flow head will encounter at inference: its own previous outputs.

Connection to DMD2's backward simulation. The paper notes that in DMD2 terminology, rollout "can be viewed as 'backward simulation' of the inner flow, but without detaching the gradient computation" (Section 3.2). Standard DMD2 backward simulation runs the student's sampling process to generate training targets for the outer loop but detaches gradients to avoid backpropagating through the full sampling chain. TMD's rollout keeps gradients attached, making it a stricter form of simulation that directly optimizes the end-to-end sampling quality.

Complete TMD Algorithm

Algorithm 2: Student update step (pseudocode from the paper).

The complete training procedure alternates between Stage 1 and Stage 2, with Stage 1 running for a fixed number of iterations before switching to Stage 2:

Given x ~ p_data, x_1 ~ N(0, I), t_i ~ Unif({t_1, ..., t_M})
x_{t_i} = (1 - t_i) x + t_i x_1          # Forward diffusion (Eq. 1)
m = m_θ(x_{t_i}, t_i)                    # Main backbone features

if stage_one:
    y = x_1 - x                          # DTM target (Eq. 3)
    y_1 ~ N(0, I), (s, r) ~ p_{s,r}     # Inner-flow noise and timesteps
    y_s = (1 - s) y + s y_1             # Inner-flow forward process (Eq. 5)
    u = u_θ(y_s, s, r; m)               # Average velocity prediction
    v = y_1 - y                          # Conditional velocity
    L = MeanFlow(u, v, s, r)            # MeanFlow loss (Eq. 9)
else:
    x_hat = x_1 - InnerFlow(m)           # Unrolled student output (Eq. 15)
    L = VSD(x_hat) + λ * Discriminator(x_hat)  # DMD2-v loss (Eq. 11)
    
θ = step(θ, ∇_θ L)                      # Gradient step

Algorithm 1: TMD inference (pseudocode from the paper).

At inference time, the student generates a video by running M outer transition steps, each containing N inner flow steps:

x ~ N(0, I)                              # Initial noise (x_1 in Eq. 1)
for i = M down to 1:                     # From noise to data
    m = m_θ(x, t_i)                      # Main backbone: extract features
    x = x - (t_i - t_{i-1}) * InnerFlow(m)  # Outer transition (Eq. 4)
return x                                 # Generated video

def InnerFlow(m):
    y ~ N(0, I)                          # Inner-flow noise
    for j = N down to 1:                 # From s_N=1 to s_0=0
        y = f_θ(y, s_j, s_{j-1}; m)     # Flow head: one refinement step
    return y                             # Estimated DTM target

Multi-step inference details. The outer transitions use deterministic sampling (Appendix A.3):

$x_{t_{i+1}} = \left(1 - \frac{t_{i+1}}{t_i}\right) x_{t_i} + \frac{t_{i+1}}{t_i} g_{\text{student}}(x_{t_i}, t_i)$

where g_student is the unrolled student generator. This is mathematically equivalent to the standard conditional flow sampling x_{t_{i+1}} = (1 - t_{i+1}) g_student(x_{t_i}, t_i) + t_{i+1} x_1 when x_1 is inferred from g_student and x_{t_i} (rather than sampled independently), which the paper argues is valid as long as g_student(x_{t_i}, t_i) approximates the correct conditional expectation. For TMD, independent noise y_1 ~ N(0, I) is still sampled for the inner flow in each outer step, so stochasticity is preserved through the inner loop.

The effective NFE metric (Eq. 16). To fairly compare inference cost across methods with different architectures, the paper defines:

$\text{Effective NFE} := M \left(1 + (N - 1) \frac{H}{L} \right)$

where M is the number of outer transition steps, N is the number of inner flow steps, H is the number of DiT blocks in the flow head, and L is the total number of DiT blocks in the teacher.

What it computes: The number of equivalent full-network forward passes. The first term M accounts for the main backbone (which runs once per outer step, processing all L blocks). The second term M(N-1)H/L accounts for the additional flow head computations: each of the M outer steps runs the flow head N times, but one of those N runs is already "paid for" in the main backbone term (since the flow head blocks are a subset of the full model), so only N-1 additional flow head passes per outer step are counted, each weighted by H/L to convert to full-network equivalents.

Why this metric matters: It enables apples-to-apples comparison between monolithic models (where NFE = M, since the entire network runs once per step) and decoupled models (where the effective cost is lower because the flow head is cheaper than the full backbone). For example:

• TMD-N2H5 on Wan2.1 1.3B (L=30): effective NFE = 2 × (1 + (2-1) × 5/30) = 2.33
• TMD-N4H5 on Wan2.1 1.3B: effective NFE = 2 × (1 + (4-1) × 5/30) = 3.00
• TMD-N4H5 on Wan2.1 14B (L=40): effective NFE = 2 × (1 + (4-1) × 5/40) = 2.75
• Standard 2-step DMD2-v: effective NFE = 2 (the whole network runs twice)

This metric reveals that TMD can achieve quality comparable to monolithic models with higher step counts at lower effective cost: in Table 1, TMD-N4H5 (NFE=3.00) achieves 84.67 overall, comparable to 4-step rCM (NFE=4) at 84.43, representing a ~25% compute saving.

Design Choice Justifications

Why DTM formulation y = x_1 - x over alternatives. The paper compares against y := x (predicting the clean sample directly) in Appendix B.4, Table 10. For N2H5, DTM achieves 84.68 vs. 84.18 for x target—a meaningful gap. The DTM formulation has three advantages: (1) it aligns with the teacher's pretrained velocity prediction (the teacher was trained to predict E[x_1 - x | x_t]), so the flow head initializes closer to its target function; (2) the reconstruction formula x = x_1 - y is simple and numerically stable; (3) the difference vector x_1 - x tends to have lower variance than x itself (since x_1 and x are uncorrelated, their difference concentrates around zero for high-dimensional spaces), making it easier for the flow head to predict.

Why gated fusion over concatenation (Appendix B.3, Table 9, Figure 13). Both achieve similar final performance (84.68 gated vs. 84.76 concat for N2H5), but gated fusion provides more stable convergence during training (Figure 13). The gating mechanism initializes with the gate near zero, meaning the flow head initially sees its input y_s processed almost identically to the original teacher—preserving pretrained behavior. As training progresses, the gate opens to incorporate backbone features. Concatenation, while also initializable to approximate identity (via the linear projection weight initialization described in Appendix B.3), provides less explicit control and introduced training instabilities that the authors observed empirically.

Why MeanFlow (TM-MF) over vanilla flow matching for pretraining (Table 6). TM-MF consistently outperforms TM (transition matching with standard flow matching): 84.68 vs. 84.61 for N2H5, and 84.67 vs. 84.29 for N4H5. The gap widens with more inner steps (N=4 vs. N=2), suggesting MeanFlow's ability to learn variable-length jumps becomes increasingly important as the flow head takes larger refinement steps. Standard flow matching only trains for infinitesimal steps (r → s), which is equivalent to TM-MF with r = s always. While TM-MF includes this as 75% of training batches (via the flow matching stabilization), the remaining 25% where r < s teaches the flow head the crucial skill of handling finite jumps.

Why distribution matching (DMD2-v) over trajectory matching for Stage 2. The paper's trajectory curvature analysis (Figure 12) directly motivates this choice. The Wan model's denoising trajectory has curvature exceeding 5 units near t = 1 (compared to near-zero curvature near t = 0). Trajectory matching methods must learn to follow this highly curved path, which becomes exponentially harder as the jump size increases (errors compound along the non-linear trajectory). Distribution matching sidesteps this by only requiring that the final output looks like a teacher sample, without constraining the intermediate path. The paper's results support this: DMD2-v achieves strong performance across various step counts (Table 1), while trajectory-based methods like rCM show sharper degradation at very low step counts (82.65 for 1-step rCM vs. 83.24 for 1-step DMD2-v on Wan2.1 1.3B).

Why two-stage training rather than end-to-end. The paper does not explicitly ablate single-stage vs. two-stage training, but the rationale is implicit in the architecture design. Stage 1 (TM-MF) teaches the flow head to perform iterative refinement—a skill that requires learning the flow dynamics over variable-length jumps. Stage 2 (DMD2-v) aligns the final output distribution with the teacher. If these were combined into a single stage, the distribution matching loss would need to simultaneously teach the flow head to refine AND match the teacher's distribution, creating a more challenging optimization problem. The two-stage approach factorizes the problem: first learn the mechanics of refinement (how to move along the inner-flow trajectory), then learn the objective of refinement (what the final output should look like). This is analogous to pretraining then fine-tuning, but both stages operate on the same underlying architecture.

Why freeze vs. fine-tune the main backbone. The paper's experiments use the main backbone weights from the pretrained teacher, with the flow head being the primary component that is trained (or fine-tuned). During TM-MF, the paper explicitly states "we do not detach the main backbone features during training as this would limit the flexibility needed in pretraining" (Section 3.1). This means gradients flow into the main backbone during Stage 1, allowing it to adapt its feature extraction to better serve the flow head. During Stage 2, the main backbone also receives gradients through the unrolled inner flow. The paper does not explore fully freezing the backbone as an ablation, but the gradient flow into the backbone is a deliberate choice to allow end-to-end adaptation of the decoupled architecture.

Why t_M = s_N = 0.999 instead of 1. The paper notes (Appendix A.2, footnote) that in practice, the maximum timestep is set to 0.999 rather than exactly 1 to "align with the pretraining of Wan." This is a standard practice in diffusion models: at exactly t = 1, the data is pure noise with no signal, making predictions ill-conditioned. Slightly backing off from t = 1 (to 0.999) ensures there is a tiny residual signal that stabilizes computations while being close enough to noise to serve the same functional purpose.

Why deterministic outer transitions with stochastic inner flow. The outer loop uses the deterministic transition formula (Eq. 18 in Appendix A.3) rather than the standard resampling scheme (Eq. 19). In the resampling scheme, fresh noise x_1 ~ N(0, I) is mixed with the student's output at each outer step, injecting stochasticity into the outer trajectory. The paper's deterministic scheme infers the noise from the student's output, keeping the outer path deterministic. However, stochasticity is preserved because each outer step's inner flow independently samples y_1 ~ N(0, I)—so the overall generation process remains stochastic. This design choice likely improves sample consistency (deterministic outer path means less variance in the high-level structure) while preserving diversity (stochastic inner flow means each refinement can explore different detail realizations).

4. Key Insights and Innovations

Innovation 1: The Decoupled Backbone as a First-Class Architectural Principle for Diffusion Distillation

Before TMD, the dominant assumption in diffusion distillation—shared across both trajectory-based methods like progressive distillation and consistency models, and distribution-based methods like DMD2 and adversarial distillation—was that the student model should be a monolithic drop-in replacement for the teacher. The student might have fewer sampling steps, but its architecture mirrored the teacher's: same number of layers, same forward pass structure, same role for every parameter at every step. This assumption was so ingrained that it was rarely stated explicitly; it was simply how distillation was done.

TMD challenges this assumption at a fundamental level by arguing that video diffusion transformers exhibit a functional hierarchy that should be preserved—and exploited—during distillation. The key diagnostic insight is that not all layers in a diffusion transformer serve the same computational role. Early layers extract semantic features that evolve slowly across denoising steps (object identities, scene layout, motion patterns), while later layers perform detail refinement that benefits from iteration (texture synthesis, edge sharpening, precise motion trajectories). Treating the entire network as a single black-box mapping forces every layer to be retrained for both roles simultaneously, which is wasteful because it discards the natural decomposition the pretrained model already learned.

This is not merely an architectural tweak—it represents a reframing of what distillation should optimize. Rather than asking "how can we compress 50 steps into 4 steps using the same architecture?", TMD asks "how can we restructure the architecture so that the expensive parts run only when they add value, and the cheap parts handle the iterative refinement that video quality demands?" The contribution is the principle of backbone decomposition as a distillation strategy, not just the specific gated-fusion mechanism that implements it.

The significance of this reframing extends beyond TMD's specific performance. It opens a design space that was previously invisible: the fraction of layers allocated to the flow head (H/L), the number of inner refinement steps (N), and the outer transition count (M) become independent knobs for controlling the quality-efficiency tradeoff. Figure 6 (and its extension in Figure 11) demonstrates this concretely: TMD-N2H3, TMD-N2H5, TMD-N2H8, TMD-N4H2, TMD-N4H3, and TMD-N4H5 all occupy different points in the quality-efficiency plane, and there is a consistent trend of improved quality with increased effective NFE. This fine-grained control is unavailable to monolithic methods, where the only knob is the discrete step count M. The paper shows that this flexibility is not merely theoretical: different configurations achieve similar quality at different costs (N2H5 at NFE=2.33 scores 84.68; N4H5 at NFE=3.00 scores 84.67), allowing practitioners to choose based on their latency budget rather than being locked into a single operating point.

Comparison to prior architectural decomposition work. The paper acknowledges prior work on decoupled backbones—DDT (Wang et al., 2025) reuses encoder features across denoising steps, REPA (Yu et al., 2024) aligns intermediate features with pretrained visual encoders, and TM (Shaul et al., 2025) introduces an inner flow loop for the head. However, these prior works either (a) applied decoupling for training-from-scratch rather than distillation, (b) didn't enforce the encoder-sharing during training (DDT), or (c) operated only in the image domain at much smaller scale. TMD's contribution is demonstrating that the decoupled principle is necessary for video distillation specifically, and that the functional split (semantic backbone vs. refinement head) maps naturally onto the video domain's unique challenges—where semantic understanding (what is happening across frames) and detail refinement (making it look photorealistic frame-by-frame) are genuinely separable computational tasks.

Evidence. The paper doesn't run a head-to-head "decoupled vs. monolithic with same budget" ablation (which would be computationally prohibitive at this scale), but the consistent pattern across Tables 1 and 2—where TMD configurations with fractional NFEs match or exceed monolithic methods with higher integer NFEs—provides indirect evidence for the principle. For instance, TMD-N2H5 (NFE=2.33) outperforms 4-step rCM (NFE=4) on Wan2.1 1.3B (84.68 vs. 84.43), representing a ~42% compute reduction for equivalent quality. The fact that this holds across both 1.3B and 14B teacher scales suggests the principle is robust.

Is this fundamental or incremental? The principle is fundamental—it changes what is being distilled (not a monolithic model but a functionally decomposed one) rather than how the distillation loss is computed. The specific implementation (gated fusion, H=5, etc.) is incremental engineering, but the conceptual reframing enables a new class of distillation methods that weren't previously considered. Future work on dynamic allocation (varying H or N per sample based on estimated difficulty) or on learning the optimal backbone-head split point during distillation would build directly on this reframing.

Innovation 2: Flow Head Rollout as Train-Test Gap Closure for Iterative Refinement

The paper's second distinctive contribution is the identification and solution of a specific distribution shift problem that arises when a recurrent refinement module is trained independently but deployed sequentially. This problem is not unique to TMD—any system where a model's output becomes its own input at inference time faces it—but the paper's diagnostic framing and solution are novel in the context of diffusion distillation.

The problem. In a decoupled architecture with a recurrent flow head, the training and inference procedures are fundamentally different. During standard training (without rollout), the flow head receives as input a noisy version of the true DTM target y—sampled from the forward diffusion process, which produces states along the ideal inner-flow trajectory. At inference time, however, the flow head receives its own previous output as input to the next step. If the flow head makes any prediction error (which it inevitably does), its output deviates from the ideal trajectory. This deviation becomes the input to the next step, where further errors compound. The flow head was never trained on these off-trajectory states, so it has no learned correction strategy—errors accumulate, and quality degrades.

This is a specific instance of the more general exposure bias or train-test mismatch problem, but the paper's contribution is recognizing that it is the primary bottleneck for recurrent refinement in video distillation, not a minor edge effect. The evidence for this claim is Figure 7: the performance gap between TMD with and without flow head rollout is substantial and persistent throughout training, not a small difference that could be attributed to hyperparameter tuning.

Why this is intellectually distinctive. The standard approach to recurrent module training in generative modeling has been either (a) to ignore the train-test gap and hope the model is accurate enough that off-trajectory states are rare (common in early iterative refinement work), or (b) to use scheduled sampling or teacher forcing decay, where the model is gradually exposed to its own outputs during training. TMD's rollout solution is simpler and more principled: always train on the full unrolled trajectory, making the training distribution exactly match the inference distribution. The computational cost is the key objection—unrolling N steps requires N forward passes through the flow head—but the paper argues (and demonstrates) that this cost is manageable because the flow head is deliberately kept lightweight (H << L).

The deeper insight is that the lightweight-ness of the flow head is not just about inference efficiency—it is what makes rollout training feasible. If the flow head were as expensive as the full backbone, unrolling it during training would be prohibitively costly. This creates a virtuous cycle: decouple to make the head lightweight → lightweight head enables rollout training → rollout training closes the train-test gap → closed gap improves quality → quality improvement justifies the decoupling. The paper doesn't state this cycle explicitly, but the architecture and training design choices are mutually reinforcing in exactly this way.

Comparison to DMD2's backward simulation. The paper draws an explicit connection to DMD2 (Yin et al., 2024), which uses "backward simulation" for multi-step distillation—running the student's sampling process to generate training targets. However, DMD2 detaches gradients during simulation, treating it as a data generation mechanism rather than an end-to-end optimization target. TMD's rollout keeps gradients attached, meaning the optimization directly sees the compounding effect of errors across inner steps. This is a stricter and more effective form of train-test gap closure, made possible specifically because the inner flow is lightweight enough to backpropagate through.

Evidence. Figure 7 is the key evidence: TMD-N4H5 with rollout converges faster and achieves higher final performance than without rollout. The gap is visible from early iterations and persists, indicating it's not just a final fine-tuning effect but a fundamental difference in what the model learns. Additionally, Appendix B.5 (Figure 14) provides qualitative confirmation: removing recurrence at inference (N1H5 vs. N4H5 from the same trained model) produces "noticeably lower-quality videos, exhibiting stronger artifacts and blurriness," demonstrating that the iterative refinement learned during rollout training is genuinely necessary for quality, not just a minor enhancement.

Is this fundamental or incremental? The concept of train-test gap closure is well-known in sequence modeling, but its application to diffusion distillation with a recurrent refinement head—and the demonstration that it is the critical factor rather than a minor optimization—is a significant contribution. The specific mechanism (gradient-through-unrolling) is straightforward once stated, but the paper's diagnostic framing (identifying this as the bottleneck and designing the architecture to make it affordable) elevates it from an implementation detail to a design principle.

Innovation 3: Video-Specific Distribution Matching via Timestep Shifting and Spatiotemporal Discrimination

TMD's third contribution is a set of engineering insights that make distribution matching distillation work reliably for video—insights that are easy to dismiss as "hyperparameter tuning" but that the paper demonstrates are essential to prevent catastrophic failure modes that standard metrics don't capture. This is a contribution of diagnostic methodology as much as technique.

The two failure modes. The paper identifies two distinct ways that standard DMD2 fails when applied to video:

1. Mode collapse invisible to aggregate metrics. Table 5 reports that one-step DMD2-v with and without t_dmd shifting achieves nearly identical VBench overall scores (83.24 vs. 83.22). Based on metrics alone, one would conclude timestep shifting is irrelevant. Figure 9 reveals the truth: without shifting, all generated videos exhibit severe spatial mode collapse—characters consistently appear on the left side of the frame regardless of prompt. This is a catastrophic failure that the benchmark completely misses because VBench's evaluation dimensions (subject consistency, motion smoothness, etc.) aren't designed to detect distributional collapse of this specific form.

2. KD warm-up is double-edged in ways that depend on step count. Table 4 shows that KD warm-up helps one-step generation (+0.18 overall) but hurts two-step generation (-0.60 overall). The mechanism, visible in Figure 10, is that warm-up introduces coarse-grained structural artifacts (extra objects, incorrect scene composition) that single-step generation can tolerate (the discriminator can still evaluate per-frame quality) but multi-step generation cannot correct (the artifact gets baked into the early representations and propagates through subsequent steps).

Why these findings are intellectually significant. These aren't just "tricks that work"—they reveal something about the nature of video distillation that wasn't previously understood. The fact that mode collapse can hide behind aggregate metrics is a methodological warning for the field: evaluating video distillation quality requires qualitative inspection, not just benchmark scores. The fact that warm-up has opposite effects at different step counts reveals that the initialization requirements for single-step and multi-step distillation are fundamentally different—single-step benefits from a strong initial guess because there's no opportunity to correct errors, while multi-step benefits from flexibility because errors introduced early can be amplified.

The timestep shifting insight is particularly deep because it connects to the paper's trajectory curvature analysis (Figure 12). The shifting function concentrates training signal in the high-curvature regime near t=1, where the denoising path deviates most from a straight line. This is where distribution matching is hardest—the student must learn to produce samples that, when partially noised and evaluated by the score networks, look like they came from the teacher's high-noise distribution. By focusing training on this regime, timestep shifting implicitly addresses the same trajectory curvature problem that motivated the choice of distribution matching over trajectory matching in the first place. It's a second-order correction: distribution matching already avoids the need to follow curved trajectories, but the VSD loss still involves noisy versions of student samples, and those noisy versions are more informative when the noise level corresponds to the curved part of the trajectory.

Comparison to image-domain DMD2. The original DMD2 (Yin et al., 2024) was developed for image generation and achieved strong results without these modifications. The fact that video requires them—and that the failures are qualitatively different (spatial mode collapse, structural artifacts rather than just blur or noise)—suggests that video generation has different failure modes than image generation under distribution matching. This has broader implications: techniques developed for image distillation may transfer architecturally to video but fail in deployment for reasons that don't appear in image benchmarks, requiring video-specific diagnostics.

Evidence. Tables 3-5 provide the quantitative evidence. Figure 9 and Figure 10 provide the qualitative evidence for the two failure modes. The user preference study (Figure 5) provides independent confirmation that the improvements are perceptible to humans, not just metric artifacts—users preferred TMD over DMD2-v by 63.3% for visual quality and 71.9% for prompt alignment in two-step generation.

Is this fundamental or incremental? The individual modifications (Conv3D discriminator, selective KD warm-up, timestep shifting) are incremental engineering improvements. But the diagnostic methodology—identifying that standard metrics miss catastrophic failures, and that techniques have opposite effects at different operating points—is a fundamental contribution to how video distillation should be evaluated and developed. Future work on video distillation that relies solely on VBench or similar aggregate metrics without qualitative inspection risks repeating the exact failure mode the paper documents.

Innovation 4: Synthesis of Trajectory and Distribution Approaches via Two-Stage Training

TMD's fourth contribution is the demonstration that trajectory-based pretraining and distribution-based distillation are complementary rather than competing paradigms, and that combining them in a two-stage pipeline yields performance neither achieves alone. This is a conceptual unification that challenges the implicit assumption in prior work that one must choose between trajectory matching (fast to converge, limited by curvature) and distribution matching (flexible, harder to optimize from scratch).

The complementarity argument. Trajectory-based methods (MeanFlow, consistency models) excel at learning the local geometry of the denoising path—how to move from one timestep to a nearby one. They provide dense supervision at every point along the trajectory and converge reliably because the regression target is well-defined. However, they struggle with large jumps because trajectory curvature causes the linear approximation to break down. Distribution-based methods (DMD2, VSD) excel at ensuring the final output looks realistic—they don't care about the path, only the destination. However, they provide sparse, high-variance supervision (the score difference and discriminator signals) that makes optimization from scratch unstable.

TMD's two-stage design exploits this complementarity directly. Stage 1 (TM-MF) uses trajectory-based pretraining to teach the flow head the mechanics of iterative refinement along the inner-flow trajectory—how to take a noisy y and produce a cleaner one, how to handle variable jump sizes, how to stay aligned with the teacher's velocity predictions. This is a well-conditioned learning problem because the MeanFlow objective provides smooth, per-sample supervision. Stage 2 (DMD2-v with rollout) then uses distribution-based distillation to teach the flow head the objective of refinement—what the final output should look like to match the teacher's distribution. This is a harder optimization problem, but the flow head starts from a good initialization (thanks to Stage 1) and the rollout ensures training matches inference.

Why this is novel. Prior work on combining trajectory and distribution matching (e.g., using consistency distillation as initialization for GAN training) exists in the image domain, but it's typically ad hoc—a sequential application of two methods without a principled argument for why the combination works. TMD provides that argument: trajectory matching teaches how to move, distribution matching teaches where to go. The paper doesn't just show that the two-stage approach works (Table 6); it shows that the choice of Stage 1 method matters—MeanFlow (TM-MF) consistently outperforms standard flow matching (TM), and the gap widens with more inner steps (N4H5: 84.67 vs. 84.29). This suggests that the quality of the trajectory-based pretraining directly determines how much the distribution-based distillation can improve upon it.

Evidence. Table 6 is the key ablation: replacing TM-MF with TM in Stage 1 reduces overall VBench score from 84.68 to 84.61 (N2H5) and from 84.67 to 84.29 (N4H5). The larger gap at N=4 indicates that MeanFlow's advantage—learning to handle variable-length jumps rather than only infinitesimal steps—becomes more important when the flow head takes larger refinement steps (since with more inner steps, each step covers a smaller timestep interval, but the cumulative ability to correct across steps depends on the quality of each individual jump). This is consistent with the paper's trajectory curvature argument: the inner-flow trajectory, like the outer one, has curvature, and MeanFlow's flow map learning is better equipped to handle it than standard flow matching.

Is this fundamental or incremental? The synthesis is fundamental—it establishes that trajectory and distribution matching are complementary tools that should be used together in a principled sequence, not competing alternatives. The specific two-stage implementation (TM-MF → DMD2-v) is a strong instantiation of this principle, but the principle itself—pretrain with dense trajectory supervision, then refine with distribution-level objectives—is more general. Future work could explore other combinations (e.g., consistency model pretraining + VSD distillation for video, or using different trajectory-based methods for different parts of the denoising schedule based on local curvature) that build on the same conceptual foundation.

5. Experimental Analysis

Evaluation Methodology

• Dataset. All experiments use text prompts sampled from the VidProM dataset (Wang and Yang, 2024), extended by Qwen2.5-7B (Yang et al., 2024), paired with videos generated by the Wan2.1 14B T2V teacher model—not real videos. The final training set contains 479k text-video pairs (after filtering from an initial 500k), representing a fully synthetic distillation dataset where the teacher model serves as both the quality oracle and the data generator.

• Base model(s). The paper distills Wan2.1 1.3B and 14B T2V-480p models (Team Wan et al., 2025), representing two scales of open-source video diffusion transformers with 30 and 40 DiT blocks respectively. All experiments operate on latent resolution [T, H, W] = [21, 60, 104], which decodes to 81 frames at 480 × 832 pixel resolution (5 seconds of video), with the 14B model also serving as the teacher for generating the synthetic training data used to distill both 1.3B and 14B students.

• Metrics. The primary quantitative metric is the VBench benchmark (Huang et al., 2024), which evaluates 16 text-to-video dimensions and summarizes them into three scores: overall score, quality score, and semantic score. The paper follows the official VBench evaluation protocol, uses standard VBench prompt lists for fair comparison across methods, and applies prompt augmentation via Qwen2.5-7B-Instruct (rewriting prompts to be longer and more descriptive without altering meaning)—a practice the paper notes is also used by almost all baselines, including the Wan2.1 base models themselves (Appendix A.4). A blinded two-alternative forced choice (2AFC) user preference study evaluates visual quality and prompt alignment separately, using 60 challenging prompts from VBench with 5 different seeds per prompt per model, where raters view side-by-side videos in random order and random seed.

• Baselines. The paper compares against multiple distilled video models: (1) DMD2-v, the authors' own improved version of DMD2 (Yin et al., 2024) for video, incorporating Conv3D discriminator, selective KD warm-up, and timestep shifting—this serves as both an ablation baseline and a state-of-the-art comparison; (2) rCM (Zheng et al., 2025), a large-scale continuous-time consistency model for video; (3) DOLLAR (Ding et al., 2025), distillation with latent reward optimization (using a CogVideoX variant as teacher); (4) T2V-Turbo-v2 (Li et al., 2025), a video model post-training approach (using VideoCrafter2 1.4B as teacher); (5) APT (Lin et al., 2025), diffusion adversarial post-training for one-step video generation (using Seaweed-7B as teacher). For each baseline, the paper notes the teacher model used since teacher quality directly affects distilled model performance—this is important because the Wan2.1 teacher at 50 steps achieves higher VBench scores (84.26 for 1.3B, 86.22 for 14B) than the teachers used by some baselines.

• Generation budget / compute accounting. The paper introduces effective NFE (number of function evaluations) as the universal compute metric (Eq. 16): Effective NFE = M × (1 + (N-1) × H/L), where M is outer transition steps, N is inner flow steps, H is flow head DiT blocks, and L is total DiT blocks (30 for 1.3B, 40 for 14B). This converts all methods to equivalent full-network forward passes—monolithic models simply have NFE = M (since the full network runs once per step), while TMD models have fractional NFEs reflecting that inner flow steps only process H/L of the full backbone. The paper reports both the effective NFE and the configuration (e.g., "N2H5" meaning N=2 inner steps, H=5 flow head blocks) to enable precise cost comparisons.

• Cross-validation / statistical protocol. The paper does not describe cross-validation or statistical significance testing. User preference results (Figure 5) report win rates as percentages with 300 pairwise comparisons per setting (60 prompts × 5 seeds), but no confidence intervals or p-values. VBench results are reported as single-point scores without error bars, standard deviations, or multiple training runs—so the reliability of small score differences (e.g., 84.68 vs. 84.67 in Table 6) cannot be assessed from the reported data. This is a meaningful limitation: with a single training run per configuration, differences of 0.1–0.3 VBench points may reflect training noise rather than genuine method superiority.

Main Quantitative Results

The paper organizes results along two axes: comparison against existing distilled models (Section 4.2) and ablation studies dissecting TMD's components (Section 4.3). I present the comparisons first, grouped by teacher model scale and step count, followed by the ablations.

Distilling Wan2.1 1.3B: TMD vs. Existing Methods

Table 1 presents the main comparison for distilling Wan2.1 1.3B (or similarly-sized video models) into few-step generators, grouped by the number of student denoising steps M. The 50-step teacher achieves overall score 84.26 (quality 85.30, semantic 80.09), setting an upper bound for what distillation can recover.

At M = 4 steps: TMD is not evaluated at M = 4 for the 1.3B model (the paper focuses on M = 1, 2 for TMD at this scale). The strongest M = 4 baseline is DMD2-v at 84.60 overall (quality 86.03, semantic 79.87), slightly outperforming rCM at 84.43 (quality 85.38, semantic 80.63). This establishes DMD2-v as a strong baseline—it already improves over the 50-step teacher in quality score (86.03 vs. 85.30) while losing on semantic score (79.87 vs. 80.09), suggesting some quality-semantic tradeoff.

At M = 2 steps: This is the regime where TMD shows its strongest results. TMD-N2H5 (M=2, N=2, H=5, effective NFE = 2.33) achieves overall score 84.68 (quality 85.71, semantic 80.55), which is the highest score in the entire table for any distilled model at any step count. Critically, this outperforms 4-step rCM at 84.43—meaning TMD achieves better quality with effectively 2.33 forward passes than rCM does with 4 full forward passes, representing a ~42% compute reduction for superior performance. TMD-N4H5 (NFE=3.00) achieves 84.67 (quality 85.72, semantic 80.47), essentially identical to N2H5 despite using more inner steps—suggesting diminishing returns to inner refinement at this scale for M=2. Both TMD configurations outperform the 2-step baselines: DMD2-v at 84.39 (quality 85.65, semantic 79.32), rCM at 84.09 (quality 84.90, semantic 80.86), and APT at 81.85 (quality 84.39, semantic 71.70). The gap is largest against APT (+2.83 overall) and most competitive against rCM (+0.59 overall), with TMD's advantage coming primarily from higher quality scores while rCM maintains a slight semantic score edge (80.86 vs. 80.55).

At M = 1 step: TMD-N2H5 (NFE=1.17) achieves overall score 83.80 (quality 85.07, semantic 78.69), outperforming all other 1-step methods: DMD2-v at 83.24, rCM at 82.65, and APT at 82.00. The improvement over 1-step rCM is +1.15 overall, driven by a +1.47 quality score advantage (85.07 vs. 83.60), though rCM maintains better semantic score (78.82 vs. 78.69). TMD-N4H5 (NFE=1.50) achieves 83.79—essentially identical to N2H5, again suggesting diminishing returns. The gap between 1-step and 2-step TMD is ~0.88 overall (83.80 vs. 84.68), which is meaningfully smaller than the gap for DMD2-v (83.24 vs. 84.39, gap 1.15) or rCM (82.65 vs. 84.09, gap 1.44), indicating TMD extracts more quality per additional outer step than monolithic methods.

The fractional NFE advantage. A subtle but important pattern: TMD-N2H5 achieves NFE=2.33 and outperforms 3-step DMD2-v (NFE=3, overall 84.48) and essentially matches 4-step rCM (NFE=4, overall 84.43). This demonstrates that TMD's decoupled architecture enables quality levels that would require 3–4 full forward passes from monolithic methods while using only 2.33 equivalent passes—a concrete efficiency gain that the effective NFE metric makes visible.

Distilling Wan2.1 14B: TMD vs. Existing Methods

Table 2 presents the comparison for distilling the larger Wan2.1 14B model, using TMD-N4H5 (M=1 or 2, N=4, H=5, L=40). The 50-step teacher achieves overall 86.22 (quality 86.67, semantic 84.44), setting a substantially higher ceiling than the 1.3B teacher.

At M = 2 steps: TMD-N4H5 (NFE=2.75) achieves overall 84.62 (quality 85.09, semantic 82.72), which does NOT outperform the strongest 2-step baselines: rCM achieves 85.05 (quality 85.57, semantic 82.95) and DMD2-v achieves 84.79 (quality 85.78, semantic 80.83). TMD's overall score of 84.62 is 0.43 below rCM and 0.17 below DMD2-v. Notably, TMD's semantic score (82.72) is competitive with rCM (82.95) but quality score (85.09) lags rCM (85.57). This is the only setting where TMD does not lead its step-count class, and the paper does not provide detailed analysis of why—possible explanations include: (1) the 14B model's larger capacity may make monolithic distillation relatively more effective since more parameters can absorb the compression; (2) the H=5 flow head configuration (5 out of 40 blocks, only 12.5% of the model) may be too small to capture sufficient refinement capacity for the larger model's output complexity; or (3) the 2.75 NFE budget is close to 3 full passes, reducing the relative advantage of the decoupled architecture.

At M = 1 step: This is where TMD shines for the 14B model. TMD-N4H5 (NFE=1.38) achieves overall 84.24 (quality 84.89, semantic 81.65), substantially outperforming all other 1-step methods: rCM at 83.02 (quality 83.57, semantic 80.81) and DMD2-v at 83.69 (quality 84.46, semantic 80.61). The gap over 1-step rCM is +1.22 overall, driven by a +1.32 quality score advantage. This is notable because the 14B 1-step TMD score (84.24) approaches the 14B 2-step TMD score (84.62)—a gap of only 0.38—suggesting that for the larger model, the decoupled architecture can extract most of the quality in effectively one outer step with inner refinement, whereas the 1.3B model showed a larger gap (~0.88). The paper highlights that TMD "eliminates the need for the computationally expensive KD warm-up required by one-step DMD2-v" (Section 4.2), which is a practical advantage since KD warm-up requires generating 10k trajectories from the teacher model at inference-like cost.

Comparison against the teacher. The 1-step TMD 14B model (84.24 overall) loses 1.98 points vs. the 50-step teacher (86.22). This gap decomposes as: quality drops from 86.67 to 84.89 (-1.78), semantic drops from 84.44 to 81.65 (-2.79). The larger semantic drop suggests that prompt adherence and text-video alignment suffer more from aggressive distillation than visual fidelity does—a consistent pattern across methods and scales in both tables.

User Preference Study

Figure 5 presents the 2AFC user study comparing TMD-N4H5 against DMD2-v for Wan2.1 14B distillation in one-step (M=1) and two-step (M=2) settings, with separate evaluations for visual quality and prompt alignment.

One-step setting: Users preferred TMD over DMD2-v by 51.8% for visual quality and 63.2% for prompt alignment. The visual quality preference is near parity (50% line), suggesting users found the visual fidelity of both models comparable in one-step generation—consistent with the VBench quality scores (TMD: 84.89 vs. DMD2-v: 84.46, a difference of only 0.43). The stronger prompt alignment preference (63.2%, well above parity) aligns with the semantic score gap (TMD: 81.65 vs. DMD2-v: 80.61, difference of 1.04), confirming that TMD's iterative flow-head refinement meaningfully improves how well generated videos match text descriptions.

Two-step setting: The preference gap widens substantially. Users preferred TMD over DMD2-v by 63.3% for visual quality and 71.9% for prompt alignment. The visual quality advantage (63.3%) is notable because the VBench quality scores are actually slightly lower for TMD (85.09) than DMD2-v (85.78)—a discrepancy that suggests VBench's quality dimensions may not fully capture the aspects of visual quality that humans notice, or that the VBench difference is within the noise range of single-point estimates. The prompt alignment advantage (71.9%) is the strongest result in the user study, confirming that inner-flow refinement provides genuine improvements to text-video coherence that both automated metrics and human raters detect.

Methodological notes on the user study. The study uses 60 prompts × 5 seeds = 300 pairwise comparisons per setting, with randomized order and random seed selection. The paper provides the user study interface screenshot (Figure 21) and notes that raters perform "independent pairwise comparisons for two separate criteria"—meaning each video pair is evaluated twice by the same rater (once for visual quality, once for prompt alignment), which may introduce criterion contamination (judgments on one dimension influencing the other). No inter-rater reliability statistics are reported.

Performance-Efficiency Tradeoff

Figure 6 (and its extension in Figure 11 including M=1 settings) maps the quality-efficiency landscape for TMD on Wan2.1 1.3B by varying the architectural hyperparameters N (inner steps), H (flow head blocks), and M (outer steps), plotting overall VBench score against effective NFE. The key finding is a consistent positive relationship between effective NFE and quality, but with important non-linearities.

For M=2 (Figure 6): As effective NFE increases from ~2.0 (N2H3) to ~3.0 (N4H5), overall score rises from approximately 84.40 to 84.68, with most configurations clustering between 84.55 and 84.68. The curve is roughly logarithmic—initial gains from adding flow head capacity or inner steps are meaningful, but diminishing returns set in quickly. For example: N2H3 (NFE=2.13, minimal configuration) achieves ~84.40, N2H5 (NFE=2.33, +0.20 NFE) reaches 84.68, N4H5 (NFE=3.00, +0.67 more NFE) reaches 84.67—essentially zero additional gain for the extra 0.67 NFE. This suggests an optimal operating point around NFE=2.33 for the 1.3B model at M=2, beyond which additional inner refinement adds cost without benefit.

For M=1 (Figure 11): The M=1 configurations (NFE ranging from ~1.0 to ~1.5) show a similar but compressed pattern. The highest-scoring M=1 configurations (N2H5 at NFE=1.17: 83.80; N4H5 at NFE=1.50: 83.79) approach the performance of lower-end M=2 configurations (N2H3 at NFE=2.13: ~84.40), with a gap of ~0.6 overall for ~0.6 additional NFE—a roughly linear tradeoff in this region.

Comparison to DMD2-v reference points. DMD2-v at NFE=2 (84.39) sits slightly below the TMD M=2 cluster, while DMD2-v at NFE=3 (84.48) is in the middle of the cluster. This means TMD's advantage is most pronounced at lower NFE values—the decoupled architecture extracts more quality per forward pass when the total budget is tight—and diminishes as budget increases toward 3 full-network equivalents, where the fraction of compute saved by the lightweight flow head becomes smaller relative to total cost.

The paper correctly notes that this tradeoff plot "justifies the fine-grained flexibility that our method offers in balancing generation speed and visual quality" (Section 4.3). A practitioner with a latency budget of exactly 2.0 NFE can use TMD-N2H3 (~84.40) rather than being forced to choose between 2-step DMD2-v (84.39, quality) and 1-step DMD2-v (83.24, speed)—TMD fills in the continuous space between integer NFE values.

Ablation Studies and Robustness Checks

Discriminator architecture (Table 3): Comparing Conv3D, Conv1D-2D, Attention-based, and no-GAN discriminators for one-step DMD2-v on Wan2.1 1.3B. Conv3D achieves the highest overall score (83.24), outperforming Conv1D-2D (82.32, -0.92), Attention (82.36, -0.88), and no GAN (81.63, -1.61). The gap between Conv3D and the two alternative architectures (~0.9) is meaningful, and removing the GAN loss entirely causes a 1.61-point drop, confirming that adversarial training provides significant signal beyond VSD alone. The superiority of Conv3D over the separable Conv1D-2D design (used in prior work like SF-V) suggests that joint spatiotemporal processing is important for discriminating real vs. generated video—temporal artifacts often manifest as spatial inconsistencies across frames, which separable convolutions process less effectively.

KD warm-up by step count (Table 4): For one-step DMD2-v, KD warm-up helps: 83.24 with vs. 83.06 without (+0.18). For two-step DMD2-v, KD warm-up hurts: 83.79 with vs. 84.39 without (-0.60). This reversal is one of the paper's most instructive findings. With qualitative evidence (Figure 10), the paper shows that KD warm-up introduces coarse structural artifacts (e.g., generating an extra person not in the prompt) that single-step generation can tolerate but multi-step refinement cannot correct. This reveals a fundamental tension: strong initialization helps when there's no opportunity for correction (M=1), but it can over-constrain the model in ways that compound errors when multiple refinement steps are available (M≥2). A practical implication: practitioners should treat KD warm-up as a step-count-dependent hyperparameter, not a universal improvement.

Timestep shifting (Table 5, Figure 9): Two separate shifting ablations. For t_dmd shifting (noise level in VSD loss) in one-step generation: overall scores are nearly identical with (83.24) and without shifting (83.22), but Figure 9 reveals that NO shifting causes severe spatial mode collapse—all generated videos place main characters on the left side of the frame. This is a case where the benchmark metric completely fails to capture a catastrophic quality degradation, and the paper deserves credit for catching it through qualitative inspection rather than trusting the numbers. For t_student shifting (outer denoising schedule) in two-step generation: shifting substantially improves overall score from 83.44 to 84.39 (+0.95), without the hidden mode collapse that afflicted the t_dmd ablation. This asymmetry—t_dmd shifting prevents invisible collapse, t_student shifting provides visible metric gains—suggests they serve different roles: t_dmd controls distribution coverage, t_student controls step allocation quality.

Multi-step DMD2-v timestep shift sensitivity (Table 11): For 3-step and 4-step DMD2-v, the paper sweeps t_student shift γ values (5 vs. 10). At 4 steps, γ=5 achieves 84.60 overall vs. 84.53 for γ=10—a small difference suggesting robustness. At 3 steps, γ=10 achieves 84.48 vs. 84.47 for γ=5—essentially identical. The 4-step DMD2-v with γ=5 (84.60) outperforms the previously reported DMD2 baseline from rCM's paper (84.56), confirming that the DMD2-v improvements are genuine and not merely matching existing work.

MeanFlow (TM-MF) vs. standard flow matching (TM) pretraining (Table 6): For N2H5, TM-MF achieves 84.68 vs. TM at 84.61 (+0.07). For N4H5, TM-MF achieves 84.67 vs. TM at 84.29 (+0.38). The gap widens with more inner steps, supporting the paper's argument that MeanFlow's ability to learn variable-length jumps becomes increasingly important as the flow head takes more refinement steps. The N4H5 TM result (84.29) is notably lower—below even 2-step DMD2-v (84.39)—suggesting that standard flow matching pretraining with 4 inner steps may actually hurt final performance compared to using fewer inner steps, perhaps because it learns a suboptimal refinement strategy that distribution matching struggles to correct.

Flow head rollout in distillation (Figure 7): TMD-N4H5 with rollout converges faster (higher VBench score at each iteration from ~500 onward) and achieves higher final performance than without rollout. The paper doesn't report the exact final score difference numerically, but the plot shows a visible and persistent gap. This confirms the central claim that unrolling during training is necessary to close the train-test gap for recurrent refinement—without it, the flow head encounters distribution shift at inference that it never learned to handle.

Flow head recurrence at inference (Figure 14, Appendix B.5): When the same TMD-N4H5 model is run with N=1 at inference (effectively disabling recurrence on a model trained with N=4), the generated videos show "much lower quality (e.g., more artifacts and blurriness)" compared to N=4 inference. This demonstrates that the iterative refinement learned during rollout training is genuinely necessary for quality—the model didn't just learn to produce a good output in one shot and then do redundant passes; each inner step meaningfully improves the result.

Fusion type: gated vs. concatenation (Table 9, Figure 13): Both achieve similar final performance: N2H5 gated (84.68) vs. concat (84.76), N4H5 gated (84.67) vs. concat (84.66). However, Figure 13 shows that gated fusion provides more stable training convergence—the concat variant shows larger score fluctuations during training, though it eventually reaches comparable performance. This makes gated fusion the safer default, but concatenation is a viable alternative if stability issues can be managed.

Inner flow target: DTM vs. sample prediction (Table 10): Using the DTM target y = x_1 - x vs. y = x for the inner flow. For N2H5: DTM achieves 84.68 vs. 84.18 for x-target (-0.50). For N4H5: DTM achieves 84.67 vs. 84.44 for x-target (-0.23). The DTM formulation consistently outperforms, and the gap is larger with fewer inner steps (N=2 vs. N=4), suggesting the alignment with teacher velocity predictions is most valuable when the flow head has limited refinement capacity—with more steps, the model has more opportunity to correct for the less-aligned target space.

DMD2-v improvements at higher step counts (Table 11): Beyond the main 1-2 step results, the paper confirms DMD2-v scales to 3-4 steps with appropriate timestep shifting, achieving 84.48 (3-step) and 84.60 (4-step). These establish that the DMD2-v baseline itself is strong and well-tuned, making TMD's improvements over it more meaningful—they're not coming from a weak baseline.

Critical Assessment

The experiments demonstrate that TMD achieves strong performance on the VBench benchmark and in user studies for distilling Wan2.1 models to 1–2 steps. However, several limitations in the experimental design constrain the strength and generality of the claims.

Do the experiments demonstrate that the decoupled architecture causes the improvement?

The paper claims the decoupled backbone is a core innovation enabling fine-grained quality-efficiency control. The evidence is indirect: TMD with fractional NFEs achieves scores comparable to or better than monolithic methods with higher integer NFEs (e.g., TMD-N2H5 at NFE=2.33 vs. rCM at NFE=4). However, the paper does not run the critical ablation: TMD with H = L (i.e., no decoupling, the full backbone as flow head). Without this, we cannot distinguish whether the gains come from the decoupled architecture itself, from the two-stage training strategy, from the DMD2-v improvements, or from the flow head rollout—any of which might benefit a monolithic model equally. The fact that 4-step DMD2-v (84.60 on 1.3B) outperforms 2-step TMD-N4H5 with similar NFE (84.67 at NFE=3.00) suggests that at matched compute, the advantage may be small. A fair comparison would match total FLOPs or wall-clock time, not just effective NFE (which ignores the overhead of the fusion layer, recurrent connections, and potential memory access patterns).

Are the VBench differences statistically reliable?

All VBench results are reported as single-point estimates from single training runs with no error bars, confidence intervals, or multiple seeds. The test set size is the standard VBench prompt list (the paper doesn't specify the exact number, but VBench typically uses ~800 prompts across its 16 evaluation dimensions). Differences of 0.1–0.5 overall score points are treated as meaningful (e.g., TMD-N2H5 at 84.68 vs. DMD2-v at 84.39, claimed as outperformance), but without variance estimates, we cannot assess whether these differences exceed run-to-run noise. Given the known sensitivity of distillation training to random seeds and the relatively small number of training iterations (1k–5k for Stage 2, Table 7), single-run comparisons may overstate reliability. The user study provides independent confirmation with 300 comparisons per setting, but the preference percentages lack confidence intervals—a 63.3% win rate could reflect a genuine difference or could be within sampling noise depending on the variance across prompts and raters.

Do the baselines represent a fair comparison?

The baselines use different teacher models: T2V-Turbo-v2 uses VideoCrafter2 1.4B, APT uses Seaweed-7B, DOLLAR uses a CogVideoX variant. Since teacher quality strongly affects distilled model performance, the absolute VBench scores are not directly comparable across methods with different teachers—a point the paper acknowledges but does not control for. rCM and DMD2-v use the same Wan2.1 teachers as TMD, making them the most directly comparable baselines. Among these, TMD leads at M=1 and M=2 on 1.3B but does NOT lead at M=2 on 14B (rCM scores 85.05 vs. TMD's 84.62). The paper presents this result without detailed explanation or investigation—understanding why TMD falls short at this specific operating point would strengthen confidence in the method's generality.

Does the effective NFE metric capture true computational cost?

Effective NFE counts equivalent full-network forward passes but ignores: (1) the additional memory and computation from the fusion layer (a new AdaLN block processing the flow head input), (2) the recurrent connection overhead (storing and retrieving intermediate states), (3) the fact that the main backbone processes all L blocks while the flow head processes only H, but the backbone's blocks include the full spatial and temporal attention operations that dominate FLOPs—the paper doesn't provide actual FLOP counts or wall-clock timings. Two configurations with identical effective NFE might have different real-world latency due to these factors. The paper acknowledges that "system-level optimizations, such as efficient attention or feature caching, to further accelerate video generation" are future work (Section 6), but without latency measurements, claims of "speed-quality trade-off" are based on a proxy metric rather than measured speed.

Single model family, single dataset.

All experiments use Wan2.1 architectures distillated on Wan2.1-generated videos, evaluated on VBench. This represents a single point in the space of video diffusion models—Wan2.1 uses a specific DiT architecture, training recipe, and noise schedule. Whether TMD's advantages transfer to other model families (HunyuanVideo, CogVideoX, Cosmos) or to real-video datasets (rather than teacher-generated synthetic data) is untested. The teacher-generated training data introduces a potential circularity: the student learns to imitate the teacher's outputs on the teacher's own training distribution, which may amplify any teacher biases or artifacts. The VBench results of the 50-step teacher (84.26 for 1.3B, 86.22 for 14B) set the upper bound, but there is no comparison to how well TMD would perform if trained on real videos—the synthetic data choice is practical (obtaining 500k high-quality video-text pairs is expensive) but limits claims about generalization.

Missing ablations.

Several experiments would strengthen the paper's claims: (1) Flow head depth ablation beyond H=2,3,5,8: The paper sweeps these values (Figure 6) but doesn't analyze the failure mode at the extremes—is there a point where H is too small (refinement capacity insufficient) or too large (approaches monolithic, losing efficiency)? (2) Outer step count M interaction with inner steps N: Tables 1–2 show M=1 and M=2 but the interaction between M and the optimal N is unexplored—does the benefit of inner refinement diminish as M increases? (3) Training data scale: All experiments use 479k videos. How does performance scale with dataset size? If TMD requires large synthetic datasets to work well, that limits applicability to models where generating 500k teacher videos is feasible. (4) CFG scale sensitivity: The paper uses CFG scale 5 for teacher/DMD2-v and 3 for TM-MF. How does TMD's performance vary with CFG scale at inference? This matters for deployment where CFG scale is a common quality-control knob. (5) Direct latency comparison: Wall-clock generation time for TMD vs. baselines at matched VBench scores, on identical hardware, would ground the "speed-quality" claims in actual user experience.

The user study design limitation.

The user study asks the same raters to evaluate both visual quality and prompt alignment for each video pair (Figure 21), creating potential criterion contamination—a rater's judgment of visual quality might influence their prompt alignment rating for the same pair, or vice versa. Independent rater groups per criterion would avoid this. Additionally, with 60 prompts × 5 seeds = 300 pairs evaluated for two criteria = 600 judgments, the per-rater workload is unspecified—rater fatigue could affect later judgments. No demographic or qualification information about raters is provided.

The mode collapse finding is important but the remedy is limited.

Figure 9 demonstrates that standard DMD2 without t_dmd shifting produces spatially collapsed outputs despite similar VBench scores. This is a genuinely important finding about benchmark blindness. However, the paper's remedy (timestep shifting with γ=5) is shown to work only for the specific Wan2.1 1.3B architecture at one-step generation. Whether this γ generalizes to other models, step counts, or video resolutions is untested. A more systematic study of the relationship between timestep distributions and mode collapse across architectures would strengthen this contribution significantly—as it stands, the γ value is an empirical choice without theoretical grounding.

6. Limitations and Trade-offs

The Difficulty Estimation Preprocessing Cost Is Unmeasured and Potentially Dominant

TMD's two-stage training pipeline requires a dataset of 479k text-video pairs generated by the teacher model (the Wan2.1 14B T2V model running at full 50 steps). The paper is transparent about this in Appendix A (Table 7), but does not account for the computational cost of generating this dataset anywhere in its reported efficiency metrics or comparisons.

The consequence. The headline efficiency gains—e.g., TMD-N2H5 achieving quality comparable to 4-step methods while using ~42% fewer effective forward passes—are measured relative to a teacher whose full 50-step generation cost has already been paid upfront to create the training data. For a practitioner seeking to distill a new model or adapt to a new domain, the total cost is: (cost of generating 479k videos at 50 steps) + (cost of TMD training) + (cost of TMD inference). The paper's effective NFE metric only captures the last term. The generation cost alone is enormous: 479,000 videos × 50 forward passes × full model parameters (14B, operating on 21 × 60 × 104 latents with spatiotemporal attention). If each teacher forward pass takes, conservatively, several seconds on an H100 cluster, generating the training dataset represents thousands of GPU-hours—potentially dominating the total cost of deploying TMD unless amortized across very large inference volumes.

What evidence exists. The paper explicitly documents the dataset in Appendix A, Table 7: "Dataset videos: Generated by Wan2.1 14B (T2V)" with "Dataset size: 500k (479k after filtering)." The cost of this generation is never quantified. The VBench results (Tables 1–2) and the performance-efficiency tradeoff analysis (Figure 6) all report costs only in terms of student inference NFE, without amortizing the teacher generation budget that made training possible. No ablation studies vary the dataset size to determine how much synthetic data is actually necessary—it is possible that TMD would work equally well with 50k or 100k videos, which would substantially reduce the preprocessing burden.

Mitigation status. Not addressed. The paper does not discuss the training data generation cost, does not ablate dataset size, and does not amortize the cost into any reported efficiency metric. The synthetic data generation is treated as a fixed, external cost. Future work on reducing the data requirements of distribution matching distillation—or on using real video data instead of teacher-generated synthetic data to avoid the circularity—would directly address this limitation.

All Results on a Single Model Family and Single Benchmark; Generalization Is Unproven

Every experiment in the paper uses Wan2.1 architectures (1.3B and 14B T2V-480p) evaluated exclusively on VBench, with training data generated by the same Wan2.1 14B teacher. The paper acknowledges this scope implicitly by focusing all experiments on Wan2.1, but does not discuss whether the findings are expected to transfer to other video diffusion model families (HunyuanVideo, CogVideoX, Cosmos, Sora-like architectures) or to other evaluation protocols.

The consequence. Several of TMD's design choices are justified by properties that may be Wan2.1-specific. The trajectory curvature analysis (Figure 12, Appendix B.2) shows Wan trajectories have "extremely large curvature" near t=1, which motivates the choice of distribution matching over trajectory matching for Stage 2 and the timestep shifting parameters (γ=5 for t_dmd, γ=10 for t_student). Different model architectures, training recipes, or noise schedules could produce trajectories with substantially different curvature profiles, potentially invalidating the shifting hyperparameters or even the fundamental choice of distribution matching. The DTM target formulation y = x_1 - x is justified by alignment with the teacher's velocity prediction—but this alignment depends on the teacher having been trained with a velocity parameterization. Models trained with different parameterizations (e.g., noise prediction, x0-prediction) would require different formulations of the inner flow target.

The specific DiT block counts (L=30 for 1.3B, L=40 for 14B) constrain the flow head configurations. The paper sweeps H=2, 3, 5, 8 for the 1.3B model (Figure 6) but only reports H=5 for the 14B model (Table 2). The optimal H/L ratio may depend on the model's depth, width, and the specific function learned by different layers—a shallower but wider model might not exhibit the same clean semantic-to-detail hierarchy that makes decoupling effective. Additionally, the use of teacher-generated synthetic training data creates a self-reinforcing cycle: the student learns to imitate the teacher's specific generative biases and artifacts. VBench scores for the teacher (84.26 for 1.3B, 86.22 for 14B) set the ceiling, but there is no evaluation of whether TMD would perform differently if trained on real videos, or whether TMD-distilled models amplify any systematic errors present in the teacher's outputs (e.g., motion artifacts, text rendering failures, object permanence violations).

What evidence exists. All quantitative results in Tables 1–2 and Figures 5–7 are specific to Wan2.1 evaluated on VBench. The baselines that use different teacher models (T2V-Turbo-v2 on VideoCrafter2, APT on Seaweed-7B, DOLLAR on CogVideoX) are not directly comparable because teacher quality differs—a point the paper acknowledges by noting the teacher model for each baseline. There is no cross-model-family experiment where the same TMD recipe is applied to a non-Wan architecture. The curvature analysis exists only for Wan2.1 1.3B (Figure 12), not for the 14B model or any other architecture, so the claim that large trajectory curvature is a general video phenomenon remains an extrapolation from a single data point.

Mitigation status. Not addressed. The paper does not claim generalizability beyond Wan2.1 and does not discuss which findings might be architecture-dependent. The paper acknowledges in Section 6 that future work includes integrating TMD with system-level optimizations, but does not mention cross-architecture validation. A practitioner considering TMD for a non-Wan model would need to recalibrate the timestep shifting parameters, verify the DTM target formulation, and potentially re-optimize the flow head depth—all of which require the computational budget to run ablation studies at scale.

The Effective NFE Metric Omits Real-World Latency Factors and May Overstate Speed Gains

The paper measures computational cost exclusively through effective NFE (Eq. 16), which counts equivalent full-network forward passes by weighting inner flow steps by the fraction of DiT blocks they process. This metric captures the theoretical FLOP count of the transformer blocks but omits several factors that affect actual wall-clock generation time.

The consequence. TMD's decoupled architecture introduces computational patterns that effective NFE does not price in: (1) the main backbone and flow head must run sequentially within each outer step (the flow head cannot begin until the backbone's features are computed), but the backbone processes all L blocks with full spatiotemporal attention while the flow head only processes H blocks—the sequential dependency means total latency is M × (latency_backbone + N × latency_head) rather than being parallelizable across inner steps; (2) the fusion layer adds an AdaLN block (adaptive layer norm, MLP, gated residual connection) that processes the full spatial grid of the flow head input—this cost is proportional to the latent resolution [21 × 60 × 104] but is not counted in NFE; (3) the recurrent rollout during training backpropagates through N sequential flow head calls, which has memory implications not captured by FLOP counting; and (4) the flow head processes the patch embedding of y_s separately from the main backbone processing of x_t, meaning the patch embedding runs 1 + N times per outer step rather than once—again not counted in NFE.

For a concrete example: TMD-N2H5 (M=2, N=2, H=5 on L=30) reports effective NFE = 2.33. A 4-step monolithic model reports NFE = 4. The paper claims a ~42% compute reduction. But in wall-clock time, the TMD model runs: 2 × (backbone_30_blocks + 2 × head_5_blocks + fusion_overhead) vs. 4 × backbone_30_blocks. The backbone forward pass dominates latency (it processes 30 blocks with full attention on 21 × 60 × 104 tensors, while the head processes only 5 blocks). If the backbone accounts for, say, 80% of a full-model forward pass, then TMD's actual latency is roughly 2 × (0.8 + 2 × 0.13 + fusion) ≈ 2 × 1.06 = 2.12 equivalent full-model passes—closer to the 4-step baseline's wall-clock time than the 42% reduction suggests. The paper provides no wall-clock timing measurements, GPU utilization data, or memory footprint analysis anywhere in the manuscript or appendix.

What evidence exists. The paper only reports effective NFE (Eq. 16, Tables 1–2, Figure 6). The training cost of flow head rollout is analyzed briefly in Section 3.2: "if we choose 5 final DiT blocks from a 30-block DiT and unroll 2 steps, it adds less than 17% extra computation in updating the student network's parameters"—but this is a training-time estimate of parameter update cost, not an inference-time latency measurement. The performance-efficiency analysis (Figure 6) uses NFE on the x-axis, implying it represents generation speed. No latency benchmarks on any specific hardware are provided.

Mitigation status. Partially acknowledged. The paper notes in Section 6 that future work includes "integrating TMD with system-level optimizations, such as efficient attention or feature caching, to further accelerate video generation," which implies the current implementation has room for latency improvement. However, the absence of any wall-clock timing means the paper's central claim about "speed-quality trade-off" is supported only by a theoretical cost model, not by measured generation time. A practitioner deploying TMD in a latency-sensitive application cannot determine from the paper whether TMD-N2H5 at NFE=2.33 actually generates videos faster than 3-step DMD2-v at NFE=3, or whether the sequential backbone→head architecture creates pipeline bubbles that negate the theoretical FLOP savings.

Hardest Cases Show Diminishing Returns and the 14B Two-Step Result Fails to Lead

The paper's results demonstrate clear patterns of diminishing returns and, in at least one important operating regime, TMD failing to outperform simpler baselines. The difficulty binning from the prior summary already indicated that the hardest problems (bin 5) show negligible improvement regardless of compute budget, but here I focus on two additional capability boundaries evident in the experiments.

The consequence: Diminishing returns to inner refinement. Figure 6 shows that as effective NFE increases within the M=2 setting, overall VBench score saturates rapidly. Moving from N2H3 (NFE≈2.13, score≈84.40) to N2H5 (NFE=2.33, score=84.68) yields +0.28 for +0.20 NFE—a reasonable return. But moving from N2H5 (NFE=2.33, 84.68) to N4H5 (NFE=3.00, 84.67) yields zero improvement for +0.67 NFE. The N4H8 configuration (not explicitly reported but implied by the "N2H8" data point in Figure 6) appears to fall around 84.56—actually lower than N2H5. This means that for the 1.3B model at M=2, there is a hard quality ceiling around 84.68 that cannot be exceeded by adding more flow head capacity or inner steps. The ceiling is approximately 0.4 points above the 50-step teacher (84.26) in overall score, but notably the teacher achieves higher semantic score (80.09 vs. TMD's 80.55)—the distilled model actually exceeds the teacher on semantic score while slightly trailing on quality, suggesting the distillation process changes the quality-semantic tradeoff rather than uniformly improving both dimensions.

The consequence: 14B two-step underperformance. Table 2 shows TMD-N4H5 (NFE=2.75) at overall score 84.62 on Wan2.1 14B, which is below 2-step rCM (85.05, gap -0.43) and 2-step DMD2-v (84.79, gap -0.17). This is the only direct comparison where TMD fails to lead its step-count class. The paper does not analyze this failure. Possible explanations that a practitioner would need to investigate: the H=5 flow head (5 out of 40 blocks, only 12.5% of the model) may be too small for the 14B model's representational complexity—the larger model may encode proportionally more information in later layers that the small flow head cannot capture; the 14B model's trajectory curvature may differ from the 1.3B model's (no curvature analysis exists for 14B), making the Stage 2 distribution matching less effective relative to trajectory-based methods like rCM; or the interplay between outer steps and inner steps may have different scaling properties at different model sizes.

What evidence exists. The diminishing returns are visible in Figure 6—the clustering of data points in the 84.55–84.68 range for NFE 2.0–3.0 with no clear upward trend beyond NFE≈2.3. The 14B underperformance is in Table 2, rows for M=2: rCM at 85.05 vs. TMD at 84.62. The quality ceiling relative to the teacher is visible by comparing TMD-N2H5 (84.68) to the Wan2.1 1.3B 50-step teacher (84.26) in Table 1—distillation improves overall score but the semantic-to-quality tradeoff shifts. The paper provides no ablation varying H for the 14B model (only H=5 is tested), no curvature analysis for 14B, and no discussion of why rCM outperforms TMD at this specific operating point.

Mitigation status. Not addressed. The paper does not discuss the quality ceiling, does not analyze the 14B two-step result, and does not propose strategies for breaking through the saturation (e.g., larger flow heads for larger models, adaptive inner step counts, or combining TMD with other techniques). The Section 6 future work mentions "unifying the two training stages into a single-stage pipeline" but not addressing the scaling behavior across model sizes. For a practitioner considering TMD for a large video model (14B+), the paper provides no guidance on how to scale H, N, and M with model size, and no warning that the method may underperform alternatives at certain operating points.

Flow Head Recurrence Introduces a Latency-Quality Tradeoff That Cannot Be Fully Mitigated

TMD's core mechanism—iterative inner-flow refinement—creates an inherent serial dependency: within each outer transition step, the flow head must run sequentially N times because each step's output becomes the next step's input. This is fundamentally different from parallelizable approaches like best-of-N sampling or multi-chain majority voting, where generation can be batched across independent samples.

The consequence. For latency-sensitive applications where generation must complete within a strict time budget (e.g., interactive video editing, real-time content creation, or simulation environments for embodied AI), the serial inner loop imposes a hard lower bound on per-step latency that is proportional to N, regardless of available parallel compute. A user who can tolerate NFE=3.00 of total computation might prefer 3 parallel full-model passes (which can be batched) over TMD-N4H5 with the same effective NFE but 4 sequential flow head passes per outer step, because the serial chain increases the critical path length. The paper's Figure 14 (Appendix B.5) demonstrates that removing recurrence at inference (N1H5 vs. N4H5 on a model trained with N=4) produces "noticeably lower-quality videos, exhibiting stronger artifacts and blurriness"—confirming that the serial inner steps are genuinely necessary for quality, not an optional enhancement. This means the quality-efficiency tradeoff in Figure 6 is not purely about total FLOPs; it also encodes a latency-quality tradeoff where the serial depth of the inner loop directly controls quality.

This is distinct from the effective NFE limitation discussed above, which concerns the metric's accuracy in reflecting real-world cost. Here, the issue is architectural: even if effective NFE perfectly captured FLOPs, the serial nature of the flow head means total FLOPs and wall-clock latency decouple in ways that parallelizable methods do not suffer from. A system with abundant parallel compute (e.g., a large GPU cluster) cannot accelerate TMD's inner loop beyond the single-GPU latency of a forward pass through the flow head, whereas parallel sampling methods can trade compute for latency by distributing samples across devices.

What evidence exists. The recurrence necessity is demonstrated in Figure 14—the N1H5 inference mode on a model trained for N4H5 produces degraded output. The sequential dependency is architectural (Algorithm 1: the inner loop for j = N down to 1 is inherently serial because y_{s_{j-1}} = f_θ(y_{s_j}, s_j, s_{j-1}; m) requires the output of the previous iteration). The quality improvement from N=1 to N=2 to N=4 in the same model (implicitly: N4H5 with NFE=3.00 vs. N2H5 with NFE=2.33, which achieve nearly identical scores) suggests diminishing latency-quality returns at higher N. No latency measurements exist to quantify the serial overhead.

Mitigation status. Not addressed. The paper does not discuss latency as distinct from FLOPs, does not provide any parallelization analysis, and does not explore whether the inner loop could be partially parallelized (e.g., by running multiple refinement chains and selecting the best). The suggestion in Section 6 to integrate TMD with "efficient attention or feature caching" addresses the per-step cost but not the serial depth. A practitioner deploying TMD in a latency-sensitive setting would need to independently measure the latency-quality Pareto frontier and potentially choose a configuration with fewer inner steps (trading quality for latency) based on application-specific requirements—guidance the paper does not provide.

The Revision Model Analogue: TMD Does Not Combine Its Decoupled Architecture with Parallel Search Strategies

Throughout the paper, TMD's flow head is used purely for sequential refinement: a single chain of N inner steps produces a single DTM target estimate per outer transition. The paper does not explore whether the flow head could be used in parallel—for instance, running multiple independent inner-flow chains from different initial noise samples and selecting the best result via the PRM/verifier or majority voting.

The consequence. This is a missed opportunity to combine the complementary strengths of the decoupled architecture (cheap refinement) with parallel search strategies that the prior summary's paper demonstrated to be effective for medium-difficulty problems. In TMD, each outer transition samples a single y_1 ~ N(0, I) and runs one deterministic inner refinement chain. If instead TMD ran K parallel inner chains per outer step (each with its own y_1) and selected the best output via the discriminator's confidence scores or a lightweight verifier, it could potentially achieve quality comparable to higher N but with better latency (K parallel chains of length N might be faster than one chain of length 2N if parallelism is available). The paper's own prior summary demonstrated that for medium-difficulty problems, beam search with verifier guidance substantially outperformed best-of-N sampling—suggesting that combining TMD's cheap refinement with parallel search over refinement paths is a natural extension that the paper does not explore.

This is not a failure of what the paper does test, but rather a limitation of scope: TMD establishes that sequential inner refinement works and is trainable via rollout, but does not investigate whether the inner refinement budget could be allocated differently—e.g., wider (more parallel chains) rather than deeper (more sequential steps). The quality ceiling observed in Figure 6 (saturation around 84.68 for Wan2.1 1.3B) might be breakable by combining parallel exploration with sequential refinement, analogous to how the prior summary's compute-optimal policy combined parallel and sequential sampling for revisions.

What evidence exists. The paper only tests sequential inner refinement (Algorithm 1: single y_1, single chain). There is no ablation where K parallel chains are run and combined via voting, discriminator selection, or verifier guidance. The quality-efficiency analysis (Figure 6) varies only N (chain length) and H (chain capacity), not the width of parallel exploration. The user study (Figure 5) compares against DMD2-v but not against a hybrid TMD+parallel-search baseline.

Mitigation status. Not addressed in the paper. This limitation is structural: the current TMD framework is defined around a single sequential inner chain per outer step, and extending it to parallel chains would require (1) training modifications (the flow head would need to handle multiple possible refinement paths), (2) a selection mechanism (how to pick the best chain output), and (3) a revised compute accounting (how to trade off K parallel chains vs. larger N). None of these are explored. The paper's future work (Section 6) does not mention parallel search strategies. For a practitioner with access to parallel compute, the inability to invest additional GPU resources into improved TMD quality (beyond simply increasing N in a serial chain) represents an untapped dimension of the quality-efficiency tradeoff.

7. Implications and Future Directions

How This Work Changes the Landscape

TMD shifts the conversation around diffusion distillation from a focus on how to train (trajectory matching vs. distribution matching, adversarial losses vs. score distillation) toward a focus on what architecture to train. This is a conceptual reframing rather than a paradigm shift—the field was already converging on distribution matching as the preferred distillation paradigm for video, and TMD's DMD2-v baseline confirms that trajectory. What TMD changes is the architectural assumption: prior work implicitly treated the diffusion backbone as an indivisible unit whose role at each denoising step was identical. TMD demonstrates that this assumption leaves substantial efficiency on the table, and that a functionally decomposed backbone—semantic feature extraction in early layers, iterative detail refinement in later layers—enables a quality-efficiency tradeoff that monolithic distillation cannot access.

The magnitude of the shift. This is a new architectural design principle, not a new training algorithm. The paper's results demonstrate that the principle works (Tables 1–2), but the principle is more general than TMD's specific instantiation: the key insight is that the hierarchical processing structure of deep diffusion transformers—early layers computing slowly-evolving semantics, later layers computing iteratively-refining details—should be reflected in the distillation architecture. TMD's gated fusion, H=5 flow head, and two-stage training are one way to instantiate this principle, but the principle suggests a design space: varying H/L yields different compute-quality operating points (Figure 6), and the optimal split may depend on model size, video resolution, and target step count.

Reconciling prior contradictions. The paper does not explicitly resolve a pre-existing contradiction in the literature, but it implicitly reconciles two tensions that have shaped diffusion distillation research. First, the trajectory-matching vs. distribution-matching debate: TMD's two-stage design shows these are complementary rather than competing—trajectory-based pretraining provides a well-conditioned initialization that distribution-based distillation can refine (Table 6 shows TM-MF pretraining outperforming standard TM, with the gap widening at higher inner step counts). Second, the apparent tension between single-step and multi-step distillation: the paper's finding that KD warm-up helps one-step but hurts multi-step (Table 4) explains why prior work reported conflicting results about the value of teacher initialization—the initialization requirements are fundamentally different at different step counts.

Research directions that become more attractive. The decoupled backbone principle makes architecture search for distillation a first-class research direction. Rather than treating the teacher architecture as fixed and only optimizing the distillation loss, future work can jointly optimize the backbone-head split, the fusion mechanism, and the inner-outer step allocation. The paper's effective NFE metric (Eq. 16) provides a common currency for comparing architectures with different compute profiles, enabling systematic architecture search that was previously difficult because monolithic models offered only the single knob of step count. Research on dynamic compute allocation—varying the number of inner refinement steps per sample or per outer transition based on estimated difficulty—becomes natural once the architecture exposes fine-grained compute knobs.

Research directions that become less attractive. The paper's trajectory curvature analysis (Figure 12) and the strong performance of DMD2-v suggest that pure trajectory-matching approaches for few-step video distillation face a fundamental barrier: the curvature of video denoising trajectories makes large-jump mapping intrinsically difficult, regardless of algorithmic improvements. The fact that rCM—a state-of-the-art trajectory-based method—performs comparably to or worse than DMD2-v at 1–2 steps (Tables 1–2) despite being substantially more complex to train suggests diminishing returns to trajectory-matching research for the low-step-count regime. Similarly, the finding that KD warm-up introduces structural artifacts that multi-step distillation cannot correct (Figure 10) suggests that strong initialization via teacher regression, while intuitively appealing, may be counterproductive for multi-step distillation—moving research focus away from initialization schemes toward architectural and training strategies that preserve flexibility.

Follow-Up Research This Work Enables

Cross-architecture validation of the decoupled backbone principle. TMD's results are demonstrated exclusively on Wan2.1 architectures (30-block and 40-block DiTs). The central question for generality is whether the functional hierarchy that TMD exploits—semantic features in early layers, detail features in later layers—is a property of DiT-based video diffusion models in general, or specific to Wan2.1's training recipe and architecture. A strong follow-up would apply TMD's decoupled architecture to HunyuanVideo (a substantially different DiT design), CogVideoX (which uses 3D causal convolutions differently), and Cosmos (a foundation model with different pretraining objectives), measuring whether the same H/L ratio (e.g., 5/30 ≈ 17% for the flow head) produces consistent quality-efficiency improvements across architectures. A negative result—finding that some architectures lack a clean semantic-to-detail hierarchy and require substantially different H/L ratios or fusion mechanisms—would be equally informative, establishing boundary conditions for the decoupling principle and potentially revealing what architectural properties make it work.

Dynamic inner step allocation conditioned on spatiotemporal complexity. Figure 6 demonstrates that TMD's quality saturates as inner steps increase, with N2H5 and N4H5 achieving nearly identical scores on 1.3B (84.68 vs. 84.67). This average result likely masks substantial per-sample variance: some videos (simple scenes, static backgrounds, single objects) may need only N=1 inner step, while others (complex motion, fine textures, multiple interacting objects) benefit from N=4 or more. A follow-up would train a lightweight complexity predictor—operating on the main backbone's features m_t at each outer step—that estimates the expected quality gain from additional inner refinement and dynamically selects N per outer step. The training signal exists: during Stage 2 with flow head rollout, the VSD loss gradient with respect to the final output after N steps vs. after N-1 steps provides a per-sample estimate of the marginal benefit of the Nth inner step. This would convert TMD's fixed compute budget into an adaptive one, potentially achieving the same average quality as N4H5 at the average cost closer to N2H5 by allocating inner steps where they matter.

Combining TMD's inner refinement with parallel outer exploration. The paper's prior summary demonstrated that combining sequential revisions with parallel sampling achieved 4× efficiency gains over either approach alone. TMD currently runs a single deterministic inner chain per outer step. A natural extension would run K parallel inner chains per outer step (each with independent y_1 ~ N(0, I), producing K candidate DTM targets), then select the best candidate using the discriminator's confidence scores (already trained as part of DMD2-v) or a lightweight verifier operating on intermediate flow head features. This would add a width dimension to the quality-efficiency tradeoff: a practitioner with K× parallel compute could invest it in either more sequential steps (larger N, higher latency) or more parallel chains (same latency, potentially better quality through selection). The key experiment would plot the quality-compute Pareto frontier for fixed latency budgets, comparing (N=4, K=1) against (N=2, K=2) and (N=1, K=4), all at matched effective NFE per sample. The paper's flow head rollout training would need modification to handle multiple chains—potentially through a min-over-chains loss or a learned selection mechanism during distillation.

Scaling the flow head depth with model size. Table 2 shows TMD-N4H5 underperforming 2-step rCM on Wan2.1 14B (84.62 vs. 85.05), while Table 1 shows TMD leading on 1.3B. This suggests the optimal H/L ratio may scale with model size—5 blocks out of 30 (17%) may be sufficient for the 1.3B model's representational needs but 5 blocks out of 40 (12.5%) may be insufficient for the 14B model. A systematic study would sweep H/L ratios at multiple model scales (1.3B, 3B, 7B, 14B Wan2.1 variants, or across model families) to determine whether there is a scaling law for the optimal flow head fraction. The hypothesis: larger models encode proportionally more semantic information in deeper layers, requiring a smaller flow head fraction (since more of the model's capacity is devoted to detail refinement that the flow head must replicate). Alternatively, larger models may have more distributed representations where the semantic-to-detail hierarchy is less clean, requiring a larger flow head fraction to capture sufficient refinement capacity. The experiment would measure VBench scores at matched effective NFE for H/L ∈ {0.1, 0.15, 0.2, 0.25, 0.33} at each model scale, fitting a power law relating optimal H/L to parameter count. A null result (no consistent scaling relationship) would suggest the 14B underperformance is due to other factors (e.g., trajectory curvature differences, training instability), guiding investigation toward those factors.

One-stage end-to-end training with adaptive loss weighting. TMD's two-stage design (TM-MF pretraining then DMD2-v distillation) factorizes the learning problem but introduces a stage transition that may leave performance on the table: the TM-MF stage optimizes for trajectory accuracy, not final output quality, and the switch to DMD2-v may discard trajectory knowledge that would benefit distribution matching. A one-stage approach would jointly optimize a combined loss L = α(t) L_TM-MF + β(t) L_VSD + λ(t) L_GAN, where the weights are functions of training progress—trajectory loss dominates early to establish flow dynamics, distribution losses dominate late to align output quality. The challenge is the computational cost: TM-MF requires finite-difference JVP approximations that add forward passes, and DMD2-v requires fake score and discriminator updates. A strong follow-up would compare one-stage vs. two-stage at matched total training compute (not just matched iterations), measuring whether the end-to-end gradient flow through the trajectory loss provides benefits that offset the increased per-iteration cost. The ablation would also test whether adaptive weighting outperforms a hand-scheduled transition, potentially revealing that the two stages interfere with each other (e.g., trajectory loss encouraging smooth flow maps that conflict with the distribution loss encouraging sharp, mode-seeking maps).

Stress-testing TMD on out-of-distribution prompts and motion complexity. All VBench evaluation uses prompts from the VBench benchmark, which has a specific distribution of scene types, motion patterns, and prompt complexity. A stress-test would evaluate TMD on curated prompt sets designed to probe specific failure modes: (1) rapid camera motion (panning, zooming, tracking shots) where temporal coherence is hardest; (2) multiple independently moving objects with occlusion; (3) long prompts with complex spatial relationships; (4) prompts requiring fine text rendering (signs, subtitles); (5) prompts requiring consistent character appearance across scene changes. The experiment would compare TMD against the 50-step teacher and against DMD2-v at matched effective NFE on each prompt category, measuring per-category VBench dimension scores and conducting targeted user studies. The goal is identifying which types of complexity benefit most from inner refinement (and therefore justify larger N or H) vs. which are limited by the base teacher's capabilities regardless of distillation method. A finding that TMD's advantage over DMD2-v concentrates entirely on certain motion types would guide deployment decisions and motivate category-specific architectural variants (e.g., larger flow heads for high-motion categories).

Practical Applications and Downstream Use Cases

Interactive video editing with near-real-time preview. Current video diffusion models are too slow for interactive editing workflows where a user adjusts a text prompt or spatial control and expects to see the result within 1–2 seconds. TMD's 1-step generation with the 14B model achieves VBench overall score 84.24 at effective NFE = 1.38 (Table 2), while 2-step generation reaches 84.62 at NFE = 2.75. If the 1.38 NFE configuration translates to ~1.5× the latency of a single full-model forward pass (accounting for serial backbone→head overhead, conservatively ~2–3 seconds on an H100 for 480p 5s video), this brings generation into the range where an editor could iterate on prompts with tolerable wait times—especially if combined with progressive decoding (showing low-resolution previews early). The user study's finding that TMD significantly improves prompt alignment over DMD2-v (63.2% win rate for 1-step, 71.9% for 2-step, Figure 5) is particularly relevant for editing workflows where precise control matters more than absolute visual fidelity. A creative tool could deploy the 1-step model for rapid preview during prompt refinement, then run the 2-step or full 50-step teacher for final export—using TMD's fractional NFE configurations to provide smooth quality-latency interpolation that monolithic models cannot offer.

Large-scale synthetic video data generation for training downstream models. Training video understanding models (action recognition, temporal localization, video question answering) requires large-scale annotated video data that is expensive to collect. Using TMD-distilled models as data generators—producing labeled videos from text descriptions at scale—reduces the per-video generation cost by 25–35× compared to the 50-step teacher (50 steps → effective NFE ~1.4–2.75, depending on configuration). With the 14B model achieving 84.24 VBench overall at 1.38 NFE, the quality loss relative to the teacher (86.22) is ~2 points—a measurable degradation but potentially acceptable for data augmentation where quantity compensates for per-sample quality. At this cost ratio, generating 500k training videos (the size of TMD's own training set) would require roughly the compute of generating 14k–20k videos with the full teacher—making data generation for downstream tasks economically viable. The specific use case: training a video captioning or temporal grounding model on synthetic videos with automatically generated dense annotations (bounding boxes, action labels, temporal segments) that can be extracted from the diffusion model's cross-attention maps or generated programmatically from the prompt, then fine-tuning on a smaller set of real annotated videos.

On-device or edge deployment of smaller distilled models for real-time applications. While the paper's experiments focus on 1.3B and 14B models, the decoupled architecture principle scales down: distilling a smaller video model (e.g., 300M–500M parameters) using TMD with M=1, N=2–4, and H=3–5 could produce a generator that runs in near-real-time on consumer GPUs or even high-end mobile devices. The key enabler is TMD's ability to concentrate the expensive computation (the main backbone, processing full spatiotemporal attention on the complete latent tensor) into a single forward pass, with only the lightweight flow head running multiple times. For a hypothetical 400M-parameter model with L=24 DiT blocks operating on lower resolution (e.g., 16 frames at 256×256), a TMD configuration with H=4, N=3 would run 1 backbone forward pass plus 3 head forward passes, where the head processes only 4/24 ≈ 17% of the model—total effective NFE ≈ 1.33. This could plausibly generate short video clips in under 500ms on an RTX 4090, enabling real-time applications like AI-assisted animation, video stylization filters, or game asset generation. The paper's quality-efficiency tradeoff curves (Figure 6) provide a template for practitioners to choose N and H based on their specific latency budget and quality requirements, without needing to run the full ablation themselves.