Motion Attribution for Video Generation

ArXiv: 2601.08828

🎯 Pitch

Fine-tuning a video model on just 10% of training clips—selected via a new motion-aware attribution method—boosts dynamic motion scores beyond those achieved by using the full dataset. Surprisingly, the winning clips don't even contain more motion on average; their influence stems purely from what the model learns from them.

---

1. Executive Summary

This paper introduces Motive (MOTIon attribution for Video gEneration), a motion-centric, gradient-based data attribution framework that scales to modern video generation models and large datasets. Using the Wan2.1-T2V-1.3B model fine-tuned on VIDGEN-1M and 4DNeX-10M datasets, Motive isolates temporal dynamics from static appearance via motion-weighted loss masks (computing per-pixel optical flow magnitudes with AllTracker, min–max normalizing them, and bilinearly downsampling into VAE latent space to weight per-location denoising gradients), combined with a single-timestep, projected gradient estimator (fixing t=751 and a shared noise draw, normalizing by frame count to correct duration bias, and applying Fastfood Johnson–Lindenstrauss projections to 512 dimensions for tractable storage and cosine-similarity scoring). Fine-tuning on the top 10% of training data selected by Motive achieves a Dynamic Degree score of 47.6% on VBench—surpassing both random selection (41.3%), full-dataset fine-tuning (42.0%), and the motion-unaware attribution baseline (43.8%)—while earning a 74.1% human preference win rate against the pretrained base model, establishing that motion quality in generated videos can be traced to specific training clips and improved through targeted data curation even when those clips do not contain higher average motion magnitude than low-influence clips.

2. Context and Motivation

The Core Problem: We Don't Know Which Training Clips Shape Motion in Generated Videos

The fundamental question this paper tackles is deceptively simple: if you have a video generation model trained on a massive dataset, which specific training clips are responsible for the motion patterns that appear in generated videos? A model that produces a realistic bouncing ball or a fluid explosion does so because of patterns absorbed from its training data — but which data? Without being able to answer this question, practitioners are left with a black box: when motion artifacts appear (temporal flicker, physically implausible dynamics, identity drift), there is no principled way to trace them back to their source or to select data that would fix them.

This gap matters for several practical reasons the authors highlight in Section 1 and the broader paper:

• Data curation for fine-tuning: In the fine-tuning regime — where practitioners cannot retrain on internet-scale corpora and must work with smaller, carefully selected subsets — knowing which clips most influence motion would enable targeted data selection rather than blind sampling. The paper explicitly frames this as the primary use case: "High-quality data often matters most in fine-tuning, where large pretraining corpora are inaccessible and carefully selected clips can have an outsized impact" (Section 1).

• Artifact diagnosis and debugging: Video generation models exhibit a range of temporal failure modes — inconsistent trajectories, temporal flicker, identity drift, and physically implausible dynamics despite sharp individual frames (Section 2.1). Without attribution, diagnosing these failures is guesswork. With motion attribution, a practitioner could take a generated video with problematic dynamics, identify which training clips most influenced that motion, and inspect those clips for issues.

• Understanding emergent motion capabilities: Modern video generation models produce impressive dynamics — object interactions, camera motion, physical constraints — that were not explicitly programmed but emerged from data. The paper argues that "motion is the defining element of video" (Section 1) and that understanding its origins is a prerequisite for building more controllable, reliable generative systems. Motion attribution provides a quantitative tool for tracing these emergent behaviors to their roots.

• Governance and safety: The paper discusses future directions around using negative-influence filtering to "suppress undesirable or unsafe dynamics" and to "audit motion behaviors exposed by our framework" (Appendix G.3). If motion patterns in generated videos can be traced to specific training clips, then problematic patterns (e.g., violent dynamics, physically dangerous behaviors) can be identified and their causes removed — a capability that becomes increasingly important as these models are deployed in real applications.

Why Prior Data Attribution Methods Are Fundamentally Insufficient

Data attribution — methods that assign influence scores to training examples relative to model predictions — has a rich history in supervised learning (Section 2.2). Classical approaches using influence functions (Koh and Liang, 2017) quantify how upweighting a training example would change a model's prediction on a test point. More scalable methods like TracIn (Pruthi et al., 2020) and TRAK (Park et al., 2023) approximate influence via gradient inner products without requiring explicit Hessian inversion, making them feasible for modern neural networks.

Recent work has extended these ideas to image diffusion models (Section 2.2 and Appendix B.1). Diffusion-ReTrac (Xie et al., 2024) addresses the timestep-dependent bias in diffusion training by normalizing gradients and sub-sampling timesteps and noise draws for influence computation. Concept-TRAK (Park et al., 2025) extends attribution to semantic concepts by reweighting gradients with concept-specific rewards. However, all of this prior work operates on static images, where the object of attribution is visual appearance — textures, objects, compositions, styles — not temporal behavior.

The paper identifies three specific challenges that make naïve extension of these methods to videos inadequate (Section 1, Section 2.2):

1. Localizing motion so attribution focuses on dynamic regions rather than static backgrounds: Videos contain both appearance information (what objects look like, what backgrounds exist) and motion information (how objects move, deform, and interact). A naïve whole-video attribution would treat these identically, meaning a training clip could be ranked highly because it shares a similar background or object with the query, even if its motion is completely different or absent. The paper explicitly notes that naïve attribution "conflates appearance with motion, often ranking clips high just because they share backgrounds or objects, while offering little insight into dynamics" (Section 3.3). This is not just a theoretical concern — it would make the resulting influence scores useless for the stated goal of understanding and improving motion.

2. Scaling to sequences since gradients must integrate across time: Video diffusion models generate multiple frames simultaneously in a latent space, and their training loss aggregates over all frames. The gradient of this loss with respect to model parameters therefore integrates information across the entire temporal extent. Computing these gradients is more expensive than for images (each training sample is a video, not a single frame), storing them at full dimensionality is infeasible for billion-parameter models (gradient dimension $D = 1,418,996,800$ for Wan2.1-T2V-1.3B), and the number of training samples in video datasets is growing rapidly (VIDGEN-1M, 4DNeX-10M).

3. Capturing temporal relations like velocity, acceleration, and trajectory coherence that single-frame attribution cannot measure: Motion is inherently a cross-frame phenomenon. The trajectory of an object, the deformation of a material, the interaction between multiple moving entities — none of these can be captured by examining individual frames in isolation. Methods designed for images have no mechanism for measuring whether a training video's gradients encode information about temporal coherence, because they were never designed to distinguish temporal from spatial information in the first place.

The paper frames this gap starkly in Section 2.2:

"Why vanilla attribution is insufficient for videos. Naïvely applying gradient-based attribution to video diffusion risks treating appearance and motion alike, often overemphasizing low-level appearance matches (objects, textures, backgrounds) while overlooking dynamics... Motion is distributed across frames and temporal horizons and entangled with static cues, so influence cannot be assigned by considering frames independently."

Where Existing Video Generation Approaches Fall Short

The paper positions itself against two parallel research threads, both of which have addressed motion but from directions that are complementary to — rather than competitive with — attribution.

Architectural and algorithmic approaches to motion modeling. A large body of work has developed specialized architectures for video generation that explicitly model temporal structure: 3D U-Nets or 2D U-Nets augmented with temporal attention (Ho et al., 2022; Blattmann et al., 2023; Peebles et al., 2023), causal or sliding-window context for autoregressive generation, factorized space-time blocks for computational efficiency, and consistency distillation (Wang et al., 2023). Other approaches inject motion control through signals like optical flow guidance (Geyer et al., 2023; Bao et al., 2023; Wang et al., 2024), pose conditioning (Chen et al., 2023; Zhang et al., 2023), or feature correspondences across frames.

The paper acknowledges these contributions but identifies a critical gap (Section 3.4):

"Prior work has emphasized architectural or algorithmic changes for motion modeling, [but] many of the largest generative gains have instead come from scaling and curating massive video corpora, which in turn enable impressive motion synthesis results in video diffusion models. Yet we lack tools that quantify how specific training clips shape particular motion patterns."

In other words, the field has invested heavily in how models should process motion (through architecture) but has largely ignored what they learn about motion (through data). The paper's central claim is that this data-centric perspective is not just complementary but essential — that without motion attribution, practitioners are optimizing model architectures in the dark, unable to diagnose whether motion failures stem from model capacity or training data deficiencies.

Motion representation using optical flow and correspondence. Classical and modern optical flow methods — from Horn and Schunck (1981) and Lucas-Kanade (1981) to RAFT (Teed and Deng, 2020) — provide dense per-pixel displacement fields between video frames. These methods are widely used as motion priors during generation: for example, optical flow can guide frame-to-frame transitions or serve as an auxiliary conditioning signal.

The paper explicitly differentiates its contribution from this line of work (Appendix B.2):

"These priors are often repurposed during generation to guide dynamics, but they do not explain which training examples shaped a model's motion behavior."

Optical flow tells you what motion is present in a video, but it does not tell you which training clips caused the model to produce that motion. The paper's innovation is to use optical flow (specifically, AllTracker, as a pluggable motion estimator) not as a generation prior but as a saliency mask for reweighting gradients — a fundamentally different role.

Motion decoupling from appearance in video transformers. Recent work (Shi et al., 2025) has highlighted the challenge of decoupling motion from appearance in video diffusion transformers, showing that spatial and temporal information become entangled in the model's representations. The paper references this work (Appendix B.2) but positions its contribution as complementary: rather than trying to disentangle representations inside the model through architectural modifications, Motive disentangles influence through gradient reweighting, identifying which training clips contribute to motion patterns regardless of what the model's internal representations look like.

How This Paper Positions Itself

The paper frames its contribution through a clear conceptual innovation: extending gradient-based data attribution from the appearance domain to the motion domain by reweighting gradients with motion saliency masks. This is not a new attribution algorithm (the underlying gradient-similarity framework builds directly on Diffusion-ReTrac and TRAK) nor a new motion estimation method (AllTracker is used off-the-shelf). Instead, it is a composition of existing components in a novel configuration that solves the specific problem of tracing motion in generated videos to training data.

This positioning is made explicit through the three technical innovations the paper emphasizes (Section 1 contributions):

1. Scalable gradient computation for video models (§3.2): The paper adopts and adapts the single-timestep, common-randomness, projected-gradient approach from Diffusion-ReTrac, but explicitly addresses the video-specific challenge of frame-length bias (§3.3) — the observation that gradient magnitudes inherently scale with the number of frames, causing longer videos to appear spuriously influential regardless of their motion quality. This is a problem that simply does not exist in image attribution and required a domain-specific correction.

2. Motion-weighted loss masks (§3.4): This is the core conceptual contribution. By computing per-pixel motion magnitudes from optical flow and using them to reweight the per-location diffusion loss before gradient computation, the paper creates an influence score that emphasizes dynamic regions and de-emphasizes static backgrounds. The key design choice is loss-space masking rather than input-space masking — the motion weights are applied to the loss function, not to the video input, which means the forward noising and generation process is unchanged and the masking only affects attribution.

3. Demonstration of practical utility (§4): The paper does not just propose a method and evaluate its attribution quality through proxy metrics (though it does that, e.g., the Spearman correlation with full gradients in Figure 4). It closes the loop by showing that fine-tuning on Motive-selected data actually improves motion quality — as measured by VBench metrics and human evaluation — compared to baselines that select data based on random sampling, raw motion magnitude, or self-supervised spatiotemporal embeddings.

The paper also makes an important negative claim that distinguishes its contribution: Motive is not simply selecting "motion-rich" clips (Appendix D.1). The analysis in Figure 6 shows that the top 10% of videos by Motive influence score have a mean motion magnitude of 3.85, only 4.3% higher than the bottom 10% (3.69). Videos with high motion magnitude can receive low influence scores, and videos with modest motion can receive high influence scores. The paper argues that this is because influence is computed via gradients — a training video is influential only when it "directly allows the model to lower the loss, improving the model's ability to generate the target motion dynamics" — not because it contains more motion overall. This is a subtle but important point: if Motive were simply a motion-saliency filter, it would be a less interesting contribution because one could trivially select high-motion videos without gradient computation. The fact that it captures something deeper about training dynamics is what makes the method scientifically interesting.

The paper's use of synthetic query videos generated by Veo-3 (Appendix F.2) is another important design choice that reflects its goals. The query set is not training data — it specifies targets for attribution. By using synthetic generation, the authors can control for confounds (textured backgrounds, camera motion, scene complexity) and isolate specific motion primitives (compress, bounce, roll, explode, float, free fall, slide, spin, stretch, swing). This design choice reflects the paper's focus: it is not trying to attribute motion in arbitrary natural videos (which would require handling complex, multi-object, multi-motion scenes), but rather to establish the feasibility and utility of motion attribution in a controlled setting where the signal is clear. The paper is building a foundation, not solving the fully general problem.

Finally, the paper positions itself within the broader trajectory of the field: as video generation models scale (from millions to billions of parameters, from thousands to millions of training clips), the need for data-level understanding becomes increasingly urgent. The paper argues in its conclusion that "as models scale, such data-level understanding will be essential for building robust and reliable generative systems" — echoing similar arguments made in the image domain by works like Concept-TRAK but extending them to the more complex and less studied domain of temporal dynamics.

3. Technical Approach

3.1 Reader Orientation

Motive is a computational pipeline that takes a trained video generation model, a set of training videos, and a query video showing some specific motion, and produces a ranked list of which training videos most strongly influenced that motion — along with a curated subset of those videos to use for fine-tuning. The system solves the problem of motion attribution in video generative models by (1) making gradient computation tractable for billion-parameter models through a series of efficiency approximations, (2) correcting for a video-specific bias where longer clips appear spuriously more influential, and (3) reweighting gradients with per-pixel optical flow magnitudes so that influence scores emphasize dynamic regions rather than static backgrounds, objects, or textures. The "shape" of the solution is: precompute projected, normalized, motion-weighted gradients for every training clip once → given a query video, compute its projected motion-weighted gradient → compute cosine similarity against all stored training gradients → rank by similarity → select the top-K for fine-tuning.

3.2 Big-Picture Architecture (Diagram in Words)

The Motive system has five major components connected in a pipeline:

1. Motion Estimator (AllTracker) — takes a raw video clip in pixel space ($\mathbb{R}^{F \times H \times W \times 3}$) and produces per-pixel optical flow displacement vectors and confidence scores. This is computed once per training video and cached. It is the only component that operates in pixel space; everything else operates in VAE latent space or model parameter space.

2. Motion Mask Constructor — takes the displacement vectors from the motion estimator, computes per-pixel motion magnitudes ($M_f(h,w) = \|\mathbf{D}_f(h,w)\|_2$), min–max normalizes them to $[0,1]$ across all frames and pixels of the clip, bilinearly downsamples from pixel resolution ($H \times W$) to VAE latent resolution ($H/s \times W/s$, where $s=8$), and produces a tensor $\tilde{\mathbf{W}}(f, \tilde{h}, \tilde{w})$ of motion weights aligned with the latent grid.

3. Motion-Weighted Gradient Computer — takes a video, its conditioning, the motion mask, a fixed timestep $t_{\text{fix}} = 751$, and a fixed noise draw $\boldsymbol{\epsilon}_{\text{fix}}$, runs the VAE encoder to get latents, computes the per-location squared prediction error in latent space at each frame and spatial position, weights each location's error by the corresponding motion mask value, averages over all frames and locations (with a $1/F$ frame-length normalization), and backpropagates through the model to produce a single gradient vector $\mathbf{g}_{\text{mot}} \in \mathbb{R}^D$ where $D = 1,418,996,800$ for Wan2.1-T2V-1.3B.

4. Fastfood Projector — takes the raw gradient vector $\mathbf{g}_{\text{mot}} \in \mathbb{R}^D$ and applies a structured random projection matrix $\mathbf{P} \in \mathbb{R}^{D' \times D}$ (where $D'=512$) implemented via the Fastfood transform (matrix-vector products in $\mathcal{O}(D'\log D')$ time without ever materializing the $D' \times D$ matrix), then $\ell_2$-normalizes the result to produce a compact projected gradient $\tilde{\mathbf{g}}_{\text{mot}} \in \mathbb{R}^{512}$. This is what gets stored for each training video.

5. Influence Scorer and Subset Selector — for a query video, computes its $\tilde{\mathbf{g}}_{\text{mot}}$ through the same pipeline, then computes cosine similarity (dot product, since vectors are already normalized) against every stored training vector in $\mathcal{O}(|\mathcal{D}| \times 512)$ time, producing a scalar influence score $I_{\text{mot}}(\mathbf{v}_n, \hat{\mathbf{v}})$ per training clip. When multiple query videos are used, aggregates scores via majority voting (each clip gets a vote from a query if its score exceeds a percentile threshold $\tau$ for that query), ranks clips by total votes, and selects the top-$K$ to form the fine-tuning subset $\mathcal{S}$.

Information flows sequentially: raw video → motion estimator → motion mask → loss reweighting → gradient computation → projection → storage. At query time, the query follows the same path, and then a dot-product sweep against stored vectors produces the ranking.

3.3 Roadmap for the Deep Dive

• First, the formal problem statement (§3.1 of the paper), which establishes what motion attribution means mathematically, what properties the influence score must satisfy, and how fine-tuning subset selection maps to a ranking task. This ground the subsequent technical decisions in a clear objective.

• Second, the scalable gradient attribution machinery (§3.2 of the paper), which explains how the paper adapts prior image-domain attribution methods to the video setting: the identity-preconditioner approximation for the inverse Hessian, the common-randomness trick for variance reduction, the single-timestep variant for compute savings, and the Fastfood projection for storage tractability. These are the "plumbing" that make the method feasible at all for billion-parameter models.

• Third, the video-specific frame-length bias fix (§3.3 of the paper), which addresses a problem that simply does not exist in image attribution — the fact that gradient magnitudes scale with clip duration, causing longer videos to dominate rankings regardless of motion quality. This is a domain-specific correction that is essential for meaningful attribution.

• Fourth, the core motion attribution mechanism (§3.4 of the paper), which is where the paper's main technical novelty lives. I will walk through the entire pipeline from raw video to motion-weighted loss: how AllTracker extracts displacements, how motion magnitude is computed and normalized, how the mask is mapped into latent space, how the per-location loss is weighted and averaged, and how the resulting gradient differs from a standard whole-clip gradient. This is the heart of the paper.

• Fifth, the subset selection procedure (§3.5 of the paper), which explains how individual influence scores are aggregated across multiple query videos (via percentile-thresholded majority voting) and how the top-$K$ ranking is converted into a fine-tuning dataset. This closes the loop from attribution to practical data curation.

• Sixth, the computational efficiency analysis (§3.6 of the paper), which quantifies the cost of each pipeline stage in terms of complexity classes and wall-clock time, justifying why the method is practical despite the seemingly prohibitive cost of per-sample gradient computation for 10k videos on a 1.3B-parameter model.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a method paper whose core idea is that training data influence on motion specifically (as opposed to general video appearance) can be isolated by reweighting per-location diffusion gradients with optical-flow-derived motion saliency masks, and that this attribution signal can be used to curate fine-tuning data that improves downstream motion quality.

---

Problem Formulation: What Does Motion Attribution Mean?

The paper operates in the fine-tuning setting (Section 3.1), not in the pretraining setting. The setup is: you have a pretrained video generation model with parameters $\boldsymbol{\theta}$ (specifically, Wan2.1-T2V-1.3B, a flow-matching text-to-video model with a DiT backbone). You have a fine-tuning corpus $\mathcal{D}_{\text{ft}} = \{(\mathbf{v}_n, \mathbf{c}_n)\}_{n=1}^N$ consisting of $N$ video-conditioning pairs (e.g., 10k clips from VIDGEN-1M or 4DNeX-10M). You also have a query video $(\hat{\mathbf{v}}, \hat{\mathbf{c}})$ — a specific clip exhibiting some motion pattern you care about (e.g., a ball bouncing, a cube floating on water, a coin spinning). The task is:

Given $(\hat{\mathbf{v}}, \hat{\mathbf{c}})$, assign a motion-aware influence score $I(\mathbf{v}_n, \hat{\mathbf{v}}; \boldsymbol{\theta})$ to each training clip $(\mathbf{v}_n, \mathbf{c}_n)$ that quantifies how much that clip contributed to the temporal dynamics observed in $\hat{\mathbf{v}}$.

The paper specifies three desiderata for this influence score (Section 3.1):

• Predictivity: rankings should correlate with observed changes from actually fine-tuning on the most influential subsets. In other words, if you rank clips by influence score, take the top-$K$, fine-tune on them, and measure motion quality, the result should be better than using random clips or clips selected by other heuristics. This is the ultimate validation criterion.

• Efficiency: the computation must scale to modern video generators with billions of parameters and large fine-tuning datasets (thousands of clips), without requiring explicit Hessian inversion (which is $D \times D$ in the number of parameters), expensive per-data integration operations, or prohibitive storage of full gradients.

• Motion-centricity: the score should capture influence on motion specifically, not on appearance or static scene content. This is the key differentiator from prior work and the hardest requirement to satisfy.

The fine-tuning subset selection task follows naturally: for a budget $K \ll N$ (in practice, $K$ is 10% of the dataset, so roughly 1,000 clips out of 10,000), select the top-$K$ clips by influence score to form the subset $\mathcal{S}$. When aggregating across multiple query videos (e.g., 5 queries per motion category × 10 categories = 50 queries), the paper uses majority voting (§3.5) rather than averaging raw scores, which avoids requiring cross-query calibration of influence magnitudes.

---

Scalable Gradient-Based Attribution for Generative Models

This subsection (§3.2 of the paper) builds the computational infrastructure that makes attribution feasible. It adapts prior work from the image diffusion attribution literature (specifically Diffusion-ReTrac, Xie et al., 2024) and extends it to handle video models. The key challenge is that computing exact influence — as defined by classical influence functions — requires the inverse Hessian-vector product $-\nabla_{\boldsymbol{\theta}}\mathcal{L}(\boldsymbol{\theta}; \mathbf{x}_{\text{test}})^\top \mathbf{H}_{\boldsymbol{\theta}}^{-1} \nabla_{\boldsymbol{\theta}}\mathcal{L}(\boldsymbol{\theta}; \mathbf{x}_n)$, where $\mathbf{H}_{\boldsymbol{\theta}}$ is the $D \times D$ Hessian of the training loss with respect to all model parameters. For a 1.3B-parameter model, $D \approx 1.4 \times 10^9$, making the Hessian a matrix with $\sim 2 \times 10^{18}$ entries — impossible to store, let alone invert.

Approximating the inverse-Hessian with an identity preconditioner. The paper takes the standard practical shortcut in the literature (Koh and Liang, 2017; Pruthi et al., 2020; Park et al., 2023): replace the inverse Hessian with the identity matrix $\mathbf{I}$. This reduces influence to the gradient inner product between the test example gradient and the training example gradient:

$I(\mathbf{x}_n, \mathbf{x}_{\text{test}}) = \nabla_{\boldsymbol{\theta}}\mathcal{L}(\boldsymbol{\theta}; \mathbf{x}_{\text{test}})^\top \nabla_{\boldsymbol{\theta}}\mathcal{L}(\boldsymbol{\theta}; \mathbf{x}_n)$

This approximation is justified by prior empirical work showing that gradient similarity preserves relative influence rankings well enough for practical subset selection, even though it discards curvature information. The computational win is enormous: instead of solving a linear system involving the Hessian, we only need to compute and store gradients.

Why not use the full Hessian? The paper acknowledges the approximation quality tradeoff implicitly (by citing the TRAK and TracIn work that established this practice) but does not belabor it — the practical impossibility of Hessian computation for billion-parameter models is treated as a given. This is standard in the field.

Challenge 1: Averaging over timesteps without prohibitive cost. For diffusion and flow-matching models, the training loss is an expectation over timesteps $t$ and noise draws $\boldsymbol{\epsilon}$:

$\mathcal{L}_{\text{diff}}(\boldsymbol{\theta}; \mathbf{v}, \mathbf{c}) = \mathbb{E}_{t, \boldsymbol{\epsilon}}\left[\|\boldsymbol{\epsilon}_{\boldsymbol{\theta}}(\mathbf{z}(t, \boldsymbol{\epsilon}), \mathbf{c}, t) - \boldsymbol{\epsilon}\|_2^2\right]$

where $\mathbf{z}(t, \boldsymbol{\epsilon}) = \alpha_t \mathbf{h} + \sigma_t \boldsymbol{\epsilon}$ is the noisy latent at timestep $t$, $\boldsymbol{\epsilon}_{\boldsymbol{\theta}}$ is the model's noise prediction, and the expectation is over $t \in \{1, \ldots, T\}$ (with $T=1000$ in the paper's setup) and $\boldsymbol{\epsilon} \sim \mathcal{N}(0, \mathbf{I})$.

A naïve approach would sample multiple $(t, \boldsymbol{\epsilon})$ pairs for each training and test example, compute the loss and gradient for each pair, average, and then compute the influence score. This is computationally equivalent to running the model through $|\mathcal{T}|$ forward-backward passes per example — impossibly expensive for large datasets.

Common randomness for stable rankings (Eq. 6). The first efficiency trick is to use shared $(t, \boldsymbol{\epsilon})$ pairs between each train–test pair. The intuition is that gradient norms and directions vary significantly with $t$ (early denoising steps see very noisy inputs and produce large gradients; late steps see nearly clean inputs and produce small gradients), and this variation introduces variance in influence rankings that can be reduced by evaluating both the train and test gradients under the same noise context.

The paper defines:

$I_{\text{diff}}^1(\mathbf{x}_n, \mathbf{x}_{\text{test}}) = \frac{1}{|\mathcal{T}|} \sum_{t,\boldsymbol{\epsilon} \in \mathcal{T}} \frac{\nabla_{\boldsymbol{\theta}}\mathcal{L}_{\text{diff}}(\boldsymbol{\theta}; \mathbf{x}_{\text{test}}, t, \boldsymbol{\epsilon})}{\|\nabla_{\boldsymbol{\theta}}\mathcal{L}_{\text{diff}}(\boldsymbol{\theta}; \mathbf{x}_{\text{test}}, t, \boldsymbol{\epsilon})\|}^{\top} \frac{\nabla_{\boldsymbol{\theta}}\mathcal{L}_{\text{diff}}(\boldsymbol{\theta}; \mathbf{x}_n, t, \boldsymbol{\epsilon})}{\|\nabla_{\boldsymbol{\theta}}\mathcal{L}_{\text{diff}}(\boldsymbol{\theta}; \mathbf{x}_n, t, \boldsymbol{\epsilon})\|}$

where $\mathcal{T}$ is a set of sampled $(t, \boldsymbol{\epsilon})$ pairs, and the gradients are $\ell_2$-normalized before the inner product (making this a cosine similarity rather than an unnormalized dot product).

What it computes: For each sampled $(t, \boldsymbol{\epsilon})$ pair, it normalizes both the test gradient and the train gradient to unit length, computes their dot product (cosine similarity), and averages across all pairs in $\mathcal{T}$. The result is a single scalar in $[-1, 1]$ measuring the average alignment of test and train gradient directions under shared noise contexts.

Why this form: The $\ell_2$ normalization corrects for timestep-induced scale effects — without it, gradients from early timesteps (which have larger magnitudes) would dominate the influence score, making the ranking sensitive to the noise level rather than to data similarity. The shared sampling of $(t, \boldsymbol{\epsilon})$ ensures that both the test and train gradients are evaluated under the same noise conditions, reducing variance compared to independent draws. This approach comes directly from Diffusion-ReTrac (Xie et al., 2024) and is adapted here for video.

Single-sample variant for reduced compute (Eq. 7). The second efficiency trick goes further: instead of averaging over multiple $(t, \boldsymbol{\epsilon})$ pairs, use a single fixed timestep $t_{\text{fix}}$ and a single shared noise draw $\boldsymbol{\epsilon}_{\text{fix}} \sim \mathcal{N}(0, \mathbf{I})$ for all train–test pairs.

$I_{\text{diff}}^2(\mathbf{x}_n, \mathbf{x}_{\text{test}}) = \frac{\nabla_{\boldsymbol{\theta}}\mathcal{L}_{\text{diff}}(\boldsymbol{\theta}; \mathbf{x}_{\text{test}}, t_{\text{fix}}, \boldsymbol{\epsilon}_{\text{fix}})}{\|\nabla_{\boldsymbol{\theta}}\mathcal{L}_{\text{diff}}(\boldsymbol{\theta}; \mathbf{x}_{\text{test}}, t_{\text{fix}}, \boldsymbol{\epsilon}_{\text{fix}})\|}^{\top} \frac{\nabla_{\boldsymbol{\theta}}\mathcal{L}_{\text{diff}}(\boldsymbol{\theta}; \mathbf{x}_n, t_{\text{fix}}, \boldsymbol{\epsilon}_{\text{fix}})}{\|\nabla_{\boldsymbol{\theta}}\mathcal{L}_{\text{diff}}(\boldsymbol{\theta}; \mathbf{x}_n, t_{\text{fix}}, \boldsymbol{\epsilon}_{\text{fix}})\|}$

where $t_{\text{fix}} = 751$ (midpoint of the $T=1000$ denoising trajectory, corresponding to scheduler index 500 in the flow matching schedule) and $\boldsymbol{\epsilon}_{\text{fix}}$ is a single Gaussian draw reused for all examples.

What it computes: The cosine similarity between the normalized test gradient and the normalized train gradient, both computed at exactly the same timestep with exactly the same noise. This reduces the per-example cost from $|\mathcal{T}|$ forward-backward passes to 1.

Why this form works: The key enabling observation (from Xie et al., 2024) is that when you fix $(t_{\text{fix}}, \boldsymbol{\epsilon}_{\text{fix}})$ and share them across all examples, the resulting single-pair gradient similarities preserve relative rankings well enough for subset selection. The paper validates this in an ablation (Section 4.4): using $t=751$ achieves $\rho = 66\%$ Spearman correlation with the ground truth computed using 10 evenly-spaced timesteps. The choice of $t=751$ as the midpoint is motivated by the denoising dynamics: early timesteps (high $t$) have inputs so heavily corrupted by noise that motion cues are obscured; late timesteps (low $t$) operate on nearly formed videos where gradients reflect fine details rather than semantic structure; mid-denoising strikes a balance where gradients capture both structural and motion-related information.

Challenge 2: Storing full gradients for thousands of examples. Even with single-sample gradients, storing the raw gradient vector $\nabla_{\boldsymbol{\theta}}\mathcal{L} \in \mathbb{R}^D$ for $N = 10,000$ training examples requires $N \times D$ floating-point numbers. For Wan2.1-T2V-1.3B, $D = 1,418,996,800 \approx 1.4 \times 10^9$. At 2 bytes (bfloat16) per entry, that's roughly $10,000 \times 1.4 \times 10^9 \times 2 = 2.8 \times 10^{13}$ bytes = 28 terabytes — completely infeasible.

Fastfood projection for reduced storage (Eqs. 8–10). The third efficiency trick is to project gradients from the full parameter space $\mathbb{R}^D$ into a much smaller space $\mathbb{R}^{D'}$ using a structured random projection, store only the projected vectors, and compute influence as the cosine similarity in the projected space.

The projection matrix $\mathbf{P} \in \mathbb{R}^{D' \times D}$ is defined through the Fastfood transform (Le et al., 2014):

$\mathbf{P} := \frac{1}{\xi\sqrt{D'}} \mathbf{S}\mathbf{Q}\mathbf{G}\boldsymbol{\Pi}\mathbf{Q}\mathbf{B}$

where:

• $\mathbf{Q}$ is the Walsh–Hadamard matrix (a structured orthogonal matrix that can be applied in $\mathcal{O}(D \log D)$ time via the Fast Walsh–Hadamard transform, rather than $\mathcal{O}(D^2)$ for a dense matrix),
• $\mathbf{B}$ is a diagonal matrix with Rademacher entries (random $\pm 1$) — this provides the initial randomization,
• $\boldsymbol{\Pi}$ is a random permutation matrix — this scrambles the coordinate ordering,
• $\mathbf{G}$ is a diagonal matrix with Gaussian entries $\mathcal{N}(0, 1)$ — this provides the Gaussian scaling required for the Johnson–Lindenstrauss property,
• $\mathbf{S}$ is a diagonal rescaling matrix that controls the variance of the projection,
• $\xi$ is a variance normalization constant,
• The factor $1/\sqrt{D'}$ ensures the projection approximately preserves norms in expectation.

The key computational property of $\mathbf{P}$ is that matrix-vector multiplication $\mathbf{P}\mathbf{g}$ can be computed in $\mathcal{O}(D' \log D')$ time without ever materializing the $D' \times D$ matrix — each of the component transforms ($\mathbf{B}, \boldsymbol{\Pi}, \mathbf{G}, \mathbf{S}$) is a diagonal or permutation operation costing $\mathcal{O}(D')$, and $\mathbf{Q}$ is applied via the fast Walsh–Hadamard transform at $\mathcal{O}(D' \log D')$.

The projected, normalized gradient is:

$\tilde{\mathbf{g}}(\boldsymbol{\theta}, \mathbf{x}) := \frac{\mathbf{P} \nabla_{\boldsymbol{\theta}}\mathcal{L}_{\text{diff}}(\boldsymbol{\theta}, \mathbf{x}, t_{\text{fix}}, \boldsymbol{\epsilon}_{\text{fix}})}{\|\mathbf{P} \nabla_{\boldsymbol{\theta}}\mathcal{L}_{\text{diff}}(\boldsymbol{\theta}, \mathbf{x}, t_{\text{fix}}, \boldsymbol{\epsilon}_{\text{fix}})\|}$

What it computes: The raw gradient (a vector in $\mathbb{R}^D$) is multiplied by the Fastfood projection matrix $\mathbf{P}$ to produce a vector in $\mathbb{R}^{D'}$ (with $D' = 512$), which is then $\ell_2$-normalized to unit length. The result is a compact representation of the gradient direction that (approximately) preserves pairwise cosine similarities.

The influence score in projected space is then simply the dot product (cosine similarity, since vectors are already normalized):

$I_{\text{diff}}^3(\mathbf{x}_n, \mathbf{x}_{\text{test}}) = \tilde{\mathbf{g}}(\boldsymbol{\theta}; \mathbf{x}_{\text{test}})^{\top} \tilde{\mathbf{g}}(\boldsymbol{\theta}; \mathbf{x}_n)$

Why this form: The Johnson–Lindenstrauss lemma guarantees that random projections approximately preserve pairwise distances and angles in the original high-dimensional space when the projection dimension $D'$ is sufficiently large relative to the number of points being compared. The Fastfood implementation makes this computationally practical by avoiding dense matrix multiplication. The $\ell_2$ normalization after projection is crucial — it ensures the influence score is bounded in $[-1, 1]$ and that rankings are based on gradient direction similarity rather than magnitude, which would be distorted by the projection.

Why $D' = 512$: The paper ablates projection dimension in Section 4.4 (Figure 4). $D' = 128$ yields Spearman correlation $\rho = 46.9\%$ with full-gradient rankings. $D' = 512$ reaches $\rho = 74.7\%$. $D' = 1024$ gives $\rho = 75.7\%$ and $D' = 2048$ gives $\rho = 76.1\%$ — marginal gains. The paper selects $D' = 512$ as the knee in the tradeoff curve, providing strong ranking preservation while keeping storage at $\mathcal{O}(|\mathcal{D}| \times 512) \approx 10,000 \times 512 \times 2$ bytes $\approx 10$ MB for bfloat16 — six orders of magnitude smaller than storing full gradients.

Summary of the scalable attribution stack: The combination of (1) identity preconditioner for the inverse Hessian, (2) single fixed timestep and shared noise draw, (3) $\ell_2$ normalization of gradients, and (4) Fastfood projection to 512 dimensions reduces the problem from computing and storing $N \times D$-dimensional vectors with multiple timestep samples to computing and storing $N \times 512$-dimensional vectors with a single timestep sample, while maintaining sufficient ranking fidelity for effective subset selection.

---

Video-Specific Frame-Length Bias Fix

This subsection (§3.3 of the paper) addresses a problem that is specific to video attribution and does not arise in image attribution: the raw gradient magnitude of the diffusion loss scales with the number of frames $F$ in the video clip.

Why frame-length bias occurs. The diffusion loss $\mathcal{L}_{\text{diff}}$ (Eq. 2) averages the squared prediction error over all frames, spatial locations, and (in multi-timestep variants) timesteps. However, the gradient $\nabla_{\boldsymbol{\theta}}\mathcal{L}_{\text{diff}}$ sums contributions across all frames. A video with $F = 81$ frames will have approximately $81/16 \approx 5\times$ larger gradient magnitude than a video with $F = 16$ frames, even if the per-frame motion quality is identical. Since influence scores are computed via gradient similarity (Eqs. 6–7, 10), this magnitude difference biases rankings: longer videos will tend to have higher influence scores simply because their gradient norms are larger, regardless of whether their content is relevant to the query motion.

The paper quantifies this: without correction, gradient-based scores correlate with video length at $\rho = 78.0\%$ (Spearman correlation). In other words, rankings are dominated by clip duration, not motion quality.

The fix: normalize by frame count before projection (Eq. 11).

$\nabla_{\boldsymbol{\theta}}\mathcal{L}_{\text{diff}}(\boldsymbol{\theta}; \mathbf{v}, t_{\text{fix}}, \boldsymbol{\epsilon}_{\text{fix}}) \leftarrow \frac{1}{F} \nabla_{\boldsymbol{\theta}}\mathcal{L}_{\text{diff}}(\boldsymbol{\theta}; \mathbf{v}, t_{\text{fix}}, \boldsymbol{\epsilon}_{\text{fix}})$

where $F$ is the number of frames in video $\mathbf{v}$.

What it computes: The raw gradient (which sums contributions across $F$ frames) is divided by $F$, converting it from a sum to a per-frame average. This is done before the $\ell_2$ normalization and projection steps in Eq. 9. The subsequent $\ell_2$ normalization further stabilizes scales across examples.

Why this form: Dividing by $F$ converts the gradient from a total-frame contribution to an average-per-frame contribution. This directly counteracts the linear scaling of gradient magnitude with frame count. The alternative — not normalizing — would cause the rankings to be dominated by clip length (as demonstrated by the $\rho = 78.0\%$ correlation). The paper reports that frame-length normalization reduces spurious length correlations by 54.0% while preserving motion-based correlation, meaning rankings reflect motion relevance rather than video duration.

Why not normalize after projection? Normalizing before projection ensures that the projected representation captures per-frame gradient information rather than total-frame gradient information. If normalization were applied after projection, the projection would have already mixed frame-count-dependent signals, making the correction less clean.

Interaction with dataset preprocessing. The paper standardizes all videos to 81 frames at 16 fps before attribution, following the Wan training protocol (which requires frame counts of the form $4n+1$ for its 3D VAE). This ensures consistent processing, but the frame-length normalization is still applied because videos may have different original lengths before standardization — the standardization may pad or truncate, and the normalization ensures that these operations don't introduce bias.

Figure 5 provides a qualitative visualization of the effect: for a "float" motion query, top-ranked samples with frame-length normalization consistently show wave dynamics, floating objects, and surfing — all matching the target motion. Without normalization, top samples lack coherent similarity because rankings are driven by clip length, not content.

---

Motion Attribution: The Core Mechanism

This is the heart of the paper (§3.4). The goal is to compute a gradient that emphasizes temporal dynamics and de-emphasizes static appearance, so that when influence scores are computed via gradient similarity (Eq. 17), the ranking identifies training clips that most strongly shape the model's motion rather than its visual appearance.

The insight is to reweight the loss function spatially and temporally using motion saliency masks, so that the resulting gradient is more sensitive to parameters that affect dynamic regions and less sensitive to parameters that affect static regions. This is done in loss space, not input space — the forward noising and generation process is unchanged, and only the attribution computation uses the motion-weighted loss.

Step 1: Extract motion information from pixel-space video. Given a video $\mathbf{v} \in \mathbb{R}^{F \times H \times W \times 3}$, the paper uses AllTracker (Harley et al., 2025) — an off-the-shelf point tracking model — to extract motion information:

$A = \mathcal{A}(\mathbf{v}) \in \mathbb{R}^{F \times H \times W \times 4}$

where:

• $A_{:,:,:,0:2}$ are the optical flow channels, encoding per-pixel displacement vectors between consecutive frames,
• $A_{:,:,:,2:4}$ encode visibility and confidence scores (indicating whether a pixel is occluded or reliably tracked).

The displacement vector at each pixel location $(f, h, w)$ is extracted as:

$\mathbf{D}_f(h, w) = (A_{f,h,w,0}, A_{f,h,w,1}) = (\mathrm{d}w, \mathrm{d}h)$

where $\mathrm{d}w$ is the horizontal displacement and $\mathrm{d}h$ is the vertical displacement from frame $f$ to frame $f+1$.

Design choice: why AllTracker? The paper treats the motion estimator as a pluggable module (Appendix E: "tracker-agnostic scope"). Any dense optical flow method (e.g., RAFT) or point tracking method could be substituted. AllTracker is chosen for its practical performance, but the attribution framework does not depend on it. The visibility and confidence channels are available for future extensions (e.g., downweighting occluded regions) but are not used in the current paper's masking.

Step 2: Compute per-pixel motion magnitude. The motion magnitude at each pixel location is the Euclidean norm of the displacement vector:

$M_f(h, w) = \|\mathbf{D}_f(h, w)\|_2 = \sqrt{(\mathrm{d}w)^2 + (\mathrm{d}h)^2}$

What it computes: For each pixel in each frame, a scalar representing how much that pixel moved between the current frame and the next frame. Pixels in static regions (backgrounds) have $M_f(h,w) \approx 0$; pixels on moving objects have larger values proportional to their speed.

Step 3: Normalize motion magnitudes to $[0, 1]$ across the entire clip (Eq. 13).

$\mathbf{W}(f, h, w) = \frac{M_f(h, w) - \min_{f', h', w'} M_{f'}(h', w')}{\max_{f', h', w'} M_{f'}(h', w') - \min_{f', h', w'} M_{f'}(h', w') + \zeta}$

where $\zeta = 10^{-6}$ prevents division by zero when all motion magnitudes are equal.

What it computes: Min–max normalization across all frames and all spatial locations of the entire video. The result is a weight tensor $\mathbf{W} \in [0, 1]^{F \times H \times W}$ where $0$ corresponds to the least motion in the clip and $1$ corresponds to the most motion.

Why this form: Min–max normalization across the entire clip (not frame-by-frame) ensures that the weights reflect relative motion saliency within that specific video. A video of a fast-moving car will have high weights on the car and low weights on the background; a video with only subtle motion will have high weights on whatever is moving (even if the absolute motion is small) and low weights elsewhere. This is crucial for the method's claimed property: it emphasizes relative dynamics within each clip rather than absolute motion speed, which would bias toward fast-motion videos. The paper explicitly references prior practice in video saliency detection (Fang et al., 2013) for this design.

A subtle consequence: because normalization is per-clip, a video with very little motion will have some pixels at weight 1.0 (the maximum within that clip) even though their absolute motion is tiny. This means that in a nearly static video, the "most moving" pixels (perhaps from camera shake or subtle lighting changes) will receive full weight, while in a highly dynamic video, only the fastest-moving objects will receive full weight. The paper's analysis (Appendix D.1, Figure 6) confirms that high-influence videos span the entire motion magnitude spectrum, not just the high-motion tail — consistent with this relative-weighting design.

Step 4: Bilinearly downsample from pixel space to VAE latent space (Eq. 14).

$\tilde{\mathbf{W}}(f, \tilde{h}, \tilde{w}) = \operatorname{Bilinear}\!\left(\mathbf{W}(\cdot, \cdot, \cdot), F, \tfrac{H}{s}, \tfrac{W}{s}\right)$

where $s = 8$ is the VAE downsampling factor (so a $480 \times 832$ video produces $60 \times 104$ latent grids), and $\tilde{h}, \tilde{w}$ index the latent spatial grid.

What it computes: Standard bilinear interpolation that maps the motion weight tensor from pixel resolution $(H, W)$ to latent resolution $(H/s, W/s)$. Each latent-grid cell receives a weighted average of the motion weights from the $s \times s = 64$ pixel-grid cells that map to it.

Why bilinear downsampling: The gradient of the diffusion loss with respect to model parameters is computed in latent space — the model's denoiser operates on VAE latents $\mathbf{h} = E(\mathbf{v})$, not on pixels. The motion mask must therefore be defined on the same grid as the loss function so that per-location losses can be weighted. Bilinear interpolation is a standard, differentiable, and efficient method for spatial resampling. More sophisticated methods (e.g., learning-based downsampling) would add complexity without clear benefit, since the mask serves as a soft weighting, not a precise segmentation.

Step 5: Define the per-location squared error in latent space (Eq. 15).

$\tilde{\mathcal{L}}_{\boldsymbol{\theta}, \mathbf{v}, \mathbf{c}}(f, \tilde{h}, \tilde{w}) = \left([\boldsymbol{\epsilon}_{\boldsymbol{\theta}}(\mathbf{z}(\mathbf{v}, t_{\text{fix}}, \boldsymbol{\epsilon}_{\text{fix}}), t_{\text{fix}}, \mathbf{c})]_{f,\tilde{h},\tilde{w}} - [\boldsymbol{\epsilon}_{\text{target}}(t_{\text{fix}}, \boldsymbol{\epsilon}_{\text{fix}})]_{f,\tilde{h},\tilde{w}}\right)^2$

where:

• $\mathbf{z}(\mathbf{v}, t_{\text{fix}}, \boldsymbol{\epsilon}_{\text{fix}})$ is the noisy latent at timestep $t_{\text{fix}}$: the VAE-encoded video $\mathbf{h} = E(\mathbf{v})$ corrupted with noise $\boldsymbol{\epsilon}_{\text{fix}}$ according to the flow-matching noise schedule,
• $\boldsymbol{\epsilon}_{\boldsymbol{\theta}}(\cdot)$ is the model's prediction (the estimated noise or velocity field, depending on the objective),
• $\boldsymbol{\epsilon}_{\text{target}}$ is the target (either the injected noise for diffusion or the velocity field for flow matching),
• $[ \cdot ]_{f,\tilde{h},\tilde{w}}$ indexes a specific frame $f$ and spatial location $(\tilde{h}, \tilde{w})$ in the latent tensor.

What it computes: For each frame and each spatial position in the latent grid, the squared difference between the model's prediction and the target at that location, using the fixed $(t_{\text{fix}}, \boldsymbol{\epsilon}_{\text{fix}})$ pair. This is essentially the per-location decomposition of the standard diffusion loss (Eq. 2).

Step 6: Define the motion-weighted loss as the masked average (Eq. 16).

$\mathcal{L}_{\text{mot}}(\boldsymbol{\theta}; \mathbf{v}, \mathbf{c}) = \frac{1}{F_{\mathbf{v}}} \operatorname{mean}_{f,\tilde{h},\tilde{w}} \left[ \tilde{\mathbf{W}}_{\mathbf{v},\mathbf{c}}(f, \tilde{h}, \tilde{w}) \cdot \tilde{\mathcal{L}}_{\boldsymbol{\theta}, \mathbf{v}, \mathbf{c}}(f, \tilde{h}, \tilde{w}) \right]$

where $F_{\mathbf{v}}$ is the number of frames in video $\mathbf{v}$ (which may differ across videos).

What it computes: The per-location errors $\tilde{\mathcal{L}}$ are multiplied elementwise by the motion weights $\tilde{\mathbf{W}}$, and the result is averaged over all frames and all latent spatial locations. The factor $1/F_{\mathbf{v}}$ corrects for frame-length bias (see §3.3). The mean is computed over the product $F_{\mathbf{v}} \times (H/s) \times (W/s)$ entries.

Operational interpretation: Each latent pixel's squared prediction error is weighted by how much motion occurs at that pixel. Pixels with high motion (weight near 1.0) contribute fully to the loss; pixels with low or no motion (weight near 0.0) contribute almost nothing. The model's gradient with respect to this loss will therefore be dominated by parameters that affect predictions in high-motion regions. If the model predicts the noise incorrectly on a moving object, that error is heavily penalized; if it predicts incorrectly on a static background, that error is heavily downweighted.

Why this form — loss-space masking rather than input-space masking: An alternative design would be to mask the input video itself (e.g., zero out static regions before encoding). This would change the forward noising and denoising process — the model would see a different input, and the generated latents would differ from standard generation. Loss-space masking leaves the forward process unchanged: the same noisy latent $\mathbf{z}$ is produced, the same model prediction $\boldsymbol{\epsilon}_{\boldsymbol{\theta}}(\mathbf{z})$ is computed, and only the loss used for gradient computation is modified. This means:

• The attribution gradient reflects how the model's actual prediction on the actual input would change if parameters were updated to better match the target in motion regions.
• The generation process (during inference) is unaffected — no motion masks are used during generation.
• The masking is applied only during the attribution computation, not during the model's standard training or inference.

The paper emphasizes this distinction: "Loss-space masking leaves forward noising and generation unchanged and reweights only attribution, avoiding interactions between motion weighting and noise injection."

When $\tilde{\mathbf{W}}$ is all ones, this recovers the standard objective. This is an important sanity check: if every pixel has motion weight 1.0 (meaning uniform motion, or equivalently, no motion-based reweighting), then $\mathcal{L}_{\text{mot}}$ reduces to the standard per-frame average diffusion loss. The paper explicitly acknowledges this, establishing that the motion-weighted loss is a strict generalization of the standard loss.

Step 7: Define the motion-weighted gradient and influence score (Eq. 17).

The motion-weighted gradient is:

$\mathbf{g}_{\text{mot}}(\boldsymbol{\theta}, \mathbf{v}, t_{\text{fix}}, \boldsymbol{\epsilon}_{\text{fix}}) = \nabla_{\boldsymbol{\theta}} \mathcal{L}_{\text{mot}}(\boldsymbol{\theta}; \mathbf{v}, \mathbf{c})$

This is the gradient of the motion-weighted loss (Eq. 16) with respect to all model parameters $\boldsymbol{\theta}$. It is computed via standard backpropagation: the per-location losses are multiplied by the motion weights, averaged, and the gradient flows backward through the model.

The projected, normalized motion-weighted gradient is:

$\tilde{\mathbf{g}}_{\text{mot}}(\boldsymbol{\theta}, \mathbf{v}) := \frac{\mathbf{P} \mathbf{g}_{\text{mot}}(\boldsymbol{\theta}, \mathbf{v}, t_{\text{fix}}, \boldsymbol{\epsilon}_{\text{fix}})}{\|\mathbf{P} \mathbf{g}_{\text{mot}}(\boldsymbol{\theta}, \mathbf{v}, t_{\text{fix}}, \boldsymbol{\epsilon}_{\text{fix}})\|}$

where $\mathbf{P}$ is the same Fastfood projection matrix used in Eq. 8–9.

The motion-aware influence score between a training clip $\mathbf{v}_n$ and a query clip $\hat{\mathbf{v}}$ is:

$I_{\text{mot}}(\mathbf{v}_n, \hat{\mathbf{v}}) = \tilde{\mathbf{g}}_{\text{mot}}(\boldsymbol{\theta}, \hat{\mathbf{v}})^{\top} \tilde{\mathbf{g}}_{\text{mot}}(\boldsymbol{\theta}, \mathbf{v}_n)$

What it computes: The cosine similarity (in the projected 512-dimensional space) between the motion-weighted gradient of the query video and the motion-weighted gradient of a training video. A high score means the two videos would push the model parameters in similar directions with respect to motion-weighted loss — i.e., improving prediction on the query's motion regions would also improve prediction on the training clip's motion regions, and vice versa.

Why this form — what the motion weighting changes about the gradient: The key difference from the standard (whole-clip) gradient $\mathbf{g}_{\text{standard}} = \nabla_{\boldsymbol{\theta}}\mathcal{L}_{\text{diff}}$ is that $\mathbf{g}_{\text{mot}}$ has been reweighted so that errors on static regions contribute less to the gradient direction. Consider two training clips:

• Clip A: a static shot of a room with a ball rolling across the floor.
• Clip B: a static shot of the same room without the ball.

With standard gradients, both clips would have similar gradients (dominated by the static room appearance), and both might receive similar influence scores for a query showing a rolling ball. With motion-weighted gradients, Clip A's gradient is dominated by errors on the moving ball region, while Clip B's gradient has no strongly weighted regions (all motion weights are near zero for the static room). Clip A will have a much higher $\tilde{\mathbf{g}}_{\text{mot}}$ similarity to the query's $\tilde{\mathbf{g}}_{\text{mot}}$ than Clip B, because the query's gradient is also dominated by the moving ball region. This is how Motive isolates motion influence from appearance influence.

The paper's claim about what this enables: "Unlike video-level attribution, which treats each clip as a single unit and conflates appearance with motion, motion attribution reweights per-location gradients using motion masks, assigning influence via dynamic behavior rather than static content" (Section 3.4).

---

Most Influential Fine-Tuning Subset Selection

This subsection (§3.5 of the paper) closes the loop from attribution scores to a curated dataset $\mathcal{S}$ that can be used for fine-tuning. The task is: given influence scores $I_{\text{mot}}(\mathbf{v}_n, \hat{\mathbf{v}})$ for all $n = 1, \ldots, N$ training clips and a budget $K$ (e.g., top 10% of the dataset), produce a subset $\mathcal{S}$ of size $K$.

Single-query-point selection. For a single query video $(\hat{\mathbf{v}}, \hat{\mathbf{c}})$, the procedure is straightforward: sort all training clips by $I_{\text{mot}}(\mathbf{v}_n, \hat{\mathbf{v}})$ in descending order, and select the top-$K$. The paper notes that $K$ is chosen as a percentile of the dataset size (e.g., top 10%), not an absolute count — this ensures the subset scales consistently regardless of total dataset size.

Multi-query-point selection: majority voting across queries (Eq. 18). In practice, a practitioner cares about a motion category (e.g., "bouncing"), not just a single specific video of a bouncing ball. The paper uses 5 query videos per motion category (50 total across 10 categories) and needs to aggregate their influence signals into a single ranking.

The aggregation method is percentile-thresholded majority voting, adapted from ICONS (Wu et al., 2024):

$\operatorname{MajVote}_n = \sum_{q=1}^Q \mathbb{I}\left[ I_{\text{mot}}(\mathbf{v}_n, \hat{\mathbf{v}}_q) > \tau \right]$

where:

• $Q$ is the number of query videos (e.g., 5 for a single motion category, or 50 for the combined generalist setting),
• $\hat{\mathbf{v}}_q$ is the $q$-th query video,
• $\tau$ is a percentile threshold on the influence scores for that query,
• $\mathbb{I}[\cdot]$ is the indicator function (1 if the condition holds, 0 otherwise).

What it computes: For each training clip $\mathbf{v}_n$ and each query $\hat{\mathbf{v}}_q$, the clip receives a "vote" if its influence score for that query exceeds the percentile threshold $\tau$. The consensus score $\operatorname{MajVote}_n$ is simply the count of queries that voted for that clip. Clips are then ranked by $\operatorname{MajVote}_n$ in descending order, and the top-$K$ form the fine-tuning subset:

$\mathcal{S}_{\text{vote}}(K) = \{\mathbf{v}_n \mid \mathbf{v}_n \text{ in top-}K \text{ by } \operatorname{MajVote}\}$

Why majority voting rather than averaging raw scores: Raw influence scores are not calibrated across queries — a score of 0.8 for query A may not mean the same thing as a score of 0.8 for query B, because the gradient geometry (and hence the cosine similarity distribution) depends on the specific query. Averaging raw scores would implicitly assume cross-query comparability, which is not guaranteed. Percentile thresholding converts each query's scores to a relative ranking (above/below the $\tau$-th percentile within that query), and majority voting counts how many queries consider a clip "influential enough." The paper adopts this approach from prior work (ICONS) that established its effectiveness for multi-query attribution aggregation.

The paper describes this as emphasizing "samples that are consistently influential across multiple queries, without requiring cross-query calibration of raw scores." The percentile threshold $\tau$ is not explicitly specified in the main text (it appears to be a hyperparameter chosen based on validation performance), but the paper's experiments use $K = 10\%$ of the dataset size for all selection methods, ensuring fair comparison.

Specialist vs. generalist models. The paper trains two types of fine-tuned models (Section 4.1):

• Specialist models: trained on data selected for a single motion category (e.g., only bounce queries), using the top 10% of clips that received the most votes from the 5 queries in that category.
• Generalist models: trained on aggregated selections across all 10 motion categories (50 queries total), using majority voting across all queries.

The generalist model is evaluated in Table 1 across all motion prompts; the specialist setting is not separately evaluated in the main results but is part of the experimental design.

Interaction with the broader pipeline. The subset selection is the final step that converts the attribution analysis into a concrete data curation action. The selected subset $\mathcal{S}$ is then used for standard fine-tuning of the Wan2.1-T2V-1.3B model (updating only the DiT backbone while freezing the T5 text encoder and VAE, at resolution $480 \times 832$, learning rate $1 \times 10^{-5}$, AdamW optimizer, 1 epoch with the dataset repeated 50 times, as specified in Section 4.1 and Appendix F.1).

---

Computational Efficiency Analysis

This subsection (§3.6 of the paper) quantifies the computational cost of each pipeline stage, both in asymptotic complexity and in measured wall-clock time. The analysis is crucial for establishing that the method is practical — the upfront cost of computing per-sample gradients for 10k videos on a 1.3B-parameter model is substantial, but the paper argues it is manageable through parallelism and amortization.

Gradient computation. The dominant cost is computing $\mathbf{g}_{\text{mot}}$ for each training clip. This requires one forward pass (to compute the motion-weighted loss) and one backward pass (to compute the gradient) — denoted as $B$ units of compute. For $N$ training samples, the total cost is $\mathcal{O}(N \cdot B)$. With the single-timestep variant, $B$ corresponds to a single forward–backward pass, rather than $|\mathcal{T}|$ passes as would be required with multi-timestep averaging.

Concrete numbers on Wan2.1-T2V-1.3B with 10k training samples (Appendix G.1, Table 6):

• Computing gradients for all 10k training clips takes ~150 hours on 1 A100 GPU.
• This is embarrassingly parallel: on 64 A100 GPUs, the same computation takes ~2.3 hours.
• Computing the gradient for a single query takes ~54 seconds (one forward–backward pass on 1 A100).
• Once training gradients are precomputed and stored, adding a new query requires only its own gradient (54 seconds) plus the influence computation sweep (46 milliseconds for dot products against 10k stored vectors).

Why this cost structure matters: The paper emphasizes that the training data gradient computation is a "one-time cost" that is "amortized across all queries." In a production data curation pipeline, you would compute and store the projected gradients for your entire fine-tuning corpus once (a few hours on a modest GPU cluster), and then you could query against it repeatedly for different motion targets without recomputing. Each new query costs less than a minute.

Projection cost. Applying the Fastfood projection to each gradient costs $\mathcal{O}(D' \log D')$ per example, where $D' = 512$. This is approximately 1.97 seconds per sample for 10k samples — negligible relative to the gradient computation itself (which is dominated by the backward pass through 1.3 billion parameters).

Gradient storage. Storing full gradients would require $\mathcal{O}(N \cdot D)$ memory, which is $\sim 28$ TB for 10k samples at 1.4B parameters in bfloat16 — infeasible. Storing projected gradients requires $\mathcal{O}(N \cdot D')$, which is $\sim 10$ MB for 10k samples × 512 dimensions × 2 bytes (bfloat16) — six orders of magnitude smaller.

Data ranking compute. For a given query, computing influence scores against all $N$ training samples requires $N$ dot products in $\mathbb{R}^{D'}$: $\mathcal{O}(N \cdot D')$. Sorting the $N$ scores is $\mathcal{O}(N \log N)$. For $N = 10,000$ and $D' = 512$, the dot products take approximately 46 milliseconds and majority-vote aggregation for 50 queries takes approximately 139 milliseconds (Table 6).

Motion-specific overhead. Extracting motion masks via AllTracker costs $\mathcal{O}(N \cdot H \cdot W \cdot F)$ for dense optical flow computation on each video. The paper notes that masks are "extracted once, cached, and negligible relative to gradient cost." The runtime comparison with baselines in Table 7 (Appendix G.1) provides context: for 10k samples on 1 GPU, random selection takes <1 second, motion magnitude selection takes ~5.5 hours, optical flow computation takes ~5.7 hours, V-JEPA embedding extraction takes ~3 hours, and Motive's full pipeline takes ~150 hours (dominated by gradient computation, not motion extraction).

Comparison with baseline methods (Table 7):

• Random selection: <1 second — simply draws a random subset.
• Motion magnitude: ~5.5 hours — computes per-pixel motion magnitudes and ranks by average magnitude (no gradient computation, no model involvement). This is a heuristic baseline that tests whether simply selecting high-motion clips achieves the same downstream benefit.
• Optical flow: ~5.7 hours — similar to motion magnitude but uses more sophisticated optical flow computation.
• V-JEPA embeddings: ~3 hours — extracts self-supervised spatiotemporal features from videos using a pretrained V-JEPA model and selects representative clips via clustering or similarity.
• Motive (ours): ~150 hours — the only method that computes model-specific gradients.

The paper's argument is that this 150-hour upfront cost is justified by the downstream improvements in motion quality (Table 1: Dynamic Degree 47.6% vs. 41.3% for random, 43.8% for motion-unaware attribution) and is practical through GPU parallelism (2.3 hours on 64 GPUs).

---

Summary of Design Choices and Their Justifications

• Single fixed timestep ($t_{\text{fix}} = 751$) over multi-timestep averaging: validated by 66% Spearman correlation with the 10-timestep ground truth while being 10× cheaper; the midpoint of the denoising trajectory balances structural information (obscured at early timesteps by noise) and motion-relevant information (lost at late timesteps where fine details dominate).

• Shared noise draw ($\boldsymbol{\epsilon}_{\text{fix}}$) across all examples: ensures that gradient similarity reflects data similarity rather than noise context similarity, reducing variance in rankings.

• Identity preconditioner for the inverse Hessian: the standard practical approximation in scalable influence methods; exact Hessian inversion is impossible at 1.4B parameters.

• Fastfood Johnson–Lindenstrauss projection to $D' = 512$: reduces storage from 28 TB (full gradients for 10k samples) to 10 MB while preserving 74.7% Spearman correlation with full-gradient rankings; the knee in the tradeoff curve at 512 dimensions.

• Frame-length normalization ($1/F$ scaling before projection): corrects the video-specific bias where gradient magnitudes scale linearly with frame count, which would otherwise cause longer clips to dominate rankings regardless of motion content; reduces spurious length correlation by 54%.

• Min–max normalization of motion magnitudes across the entire clip: emphasizes relative motion saliency within each video rather than absolute motion speed, preventing bias toward fast-motion videos; consistent with prior work in video saliency detection.

• Loss-space masking rather than input-space masking: leaves the forward noising and denoising process unchanged so that the attribution gradient reflects the model's actual prediction on the actual input; avoids interactions between motion weighting and the generation process.

• Bilinear downsampling from pixel to latent space: aligns the motion mask with the spatial grid where gradients are computed; bilinear interpolation is simple, differentiable, and sufficient since the mask serves as a soft weighting.

• Majority voting with percentile thresholding for multi-query aggregation: avoids assuming cross-query comparability of raw influence scores; adopted from prior work (ICONS) that established its effectiveness for multi-query attribution aggregation.

• Pluggable motion estimator: AllTracker is used for convenience but the framework is agnostic to the specific optical flow or point tracking method; only displacement magnitudes are required, enabling substitution of alternative estimators.

• One-time gradient precomputation with per-query dot-product scoring: the expensive part (training gradients) is computed once and reused for arbitrary queries; each new query costs ~54 seconds (gradient) + 46 ms (scoring) + negligible majority-vote time, making the system practical for iterative data curation workflows.

4. Key Insights and Innovations

Innovation 1: Motion Attribution as a Conceptually New Category of Data Attribution

The paper's most fundamental contribution is not a specific algorithm but the articulation of a new category of attribution problem that simply did not exist before. Prior data attribution work — from classical influence functions (Koh & Liang, 2017) through TRAK (Park et al., 2023) to diffusion-specific methods like Diffusion-ReTrac (Xie et al., 2024) and Concept-TRAK (Park et al., 2025) — operates within a unified conceptual framework: given a model and a query output, which training examples influenced that output? The "output" could be a classification decision, a generated image, or a semantic concept, but the attribution target is always what the model produced.

Motive shifts the attribution target from what to how — from the content of generated output to the temporal dynamics that distinguish videos from static images. This is not a minor extension. Motion is not a property of individual frames; it emerges across frames. Attributing motion therefore requires measuring influence on cross-frame relationships — trajectories, deformations, velocity consistency, physical plausibility — that have no analog in single-image generation. The paper makes this distinction explicit by framing motion as "the defining element of video" (Section 1) that "naïve video-level attribution conflates appearance with motion" (Section 3.3), but the deeper conceptual move is establishing motion attribution as a legitimate and distinct scientific objective rather than treating it as appearance attribution applied to videos.

What makes this intellectually distinctive is that it reframes a perceived limitation of prior work — that image attribution methods don't capture temporal dynamics — into a positive research agenda. Before Motive, the field lacked a name for this problem, let alone a method. The paper doesn't just propose a solution; it names and formalizes a gap that, once articulated, seems obvious: of course video generation models care about motion differently from appearance, and of course understanding motion requires different attribution tools. This is the kind of contribution that shapes how subsequent researchers frame their questions, regardless of whether they adopt the specific gradient-reweighting approach.

The gap is not just conceptual but operational. Section 2.2's statement that "motion is distributed across frames and temporal horizons and entangled with static cues, so influence cannot be assigned by considering frames independently" is a diagnostic observation: the field's existing tools cannot answer the question "which training clips shaped this motion pattern?" not because they're insufficiently optimized, but because they measure the wrong thing. This is a fundamental reframing, not an incremental improvement.

Innovation 2: Loss-Space Motion Masking as a General Principle for Isolating Attribution Targets

The paper's technical innovation — reweighting per-location gradients with motion saliency masks applied in loss space — is easy to describe mechanistically (motion magnitude → normalized mask → weighted loss → gradient). What makes it intellectually significant is the design principle it embodies, which generalizes beyond motion.

Specifically, the paper makes a crucial architectural decision: apply motion masks to the loss function, not to the input video. This is non-obvious. The more intuitive approach would be to mask the input — zero out or suppress static regions in the video frames before encoding, so the model only "sees" moving objects. But input-space masking would change the forward noising and denoising process: the model would receive a different noisy latent, make different predictions, and the resulting gradients would reflect behavior on an altered input, not on the actual video. Loss-space masking, by contrast, leaves the entire forward pass untouched — the same latents, the same predictions, the same errors — and only reweights which errors contribute to the gradient.

This distinction carries a deeper insight: attribution targets can be isolated by reweighting the measurement function (the loss) rather than by modifying the model's input or architecture. The paper doesn't frame it in these abstract terms, but the implication is clear: if you want to attribute a specific property of generated output (motion, texture, composition, style), you can construct a loss that emphasizes that property in the output space and compute gradients through it, without changing anything about the model or the generation process itself. Concept-TRAK (Park et al., 2025) took a step in this direction by reweighting gradients with concept-specific rewards, but those rewards were externally defined scores on generated outputs, not spatially-resolved reweightings of the internal loss landscape. Motive's loss-space masking is both finer-grained (per-pixel, per-frame) and more principled (it directly reweights the model's training objective rather than post-hoc scoring of outputs).

The generality of this principle is underscored by the paper's "tracker-agnostic" and "model-agnostic" framing (Appendix E): the motion estimator is pluggable (any dense optical flow method works), the generator architecture is irrelevant (only per-example gradients are needed), and the objective function (diffusion or flow matching) doesn't change the masking logic. This suggests that loss-space reweighting for attribution could extend to other video properties (camera motion, object interactions, physical plausibility) or even to other modalities, without requiring architectural modifications — a conceptual template rather than a one-off solution.

Innovation 3: The Distinction Between "Motion-Rich" and "Motion-Influential" as a Diagnostic Finding

The paper makes an empirically striking and conceptually important negative claim: Motive does not simply select videos with high motion magnitude. Appendix D.1 (Figure 6) shows that the top 10% of videos by influence score have a mean motion magnitude of 3.85, only 4.3% higher than the bottom 10% (3.69). Videos span the entire motion spectrum in both the high-influence and low-influence groups, with substantial overlap in every motion-magnitude bin.

This finding is significant because it invalidates the naïve alternative hypothesis that motion quality improvements from targeted fine-tuning come simply from selecting clips that contain lots of motion — what the paper could have called a "motion-saliency filter." If that were true, then the "motion magnitude" baseline in Table 1 (which selects the 10% of clips with the highest average optical flow) should perform comparably to Motive. It doesn't: motion magnitude selection achieves a Dynamic Degree of 40.1% versus Motive's 47.6%, and actually degrades motion smoothness (95.7% vs. 96.3% for the base model). The fact that a simple motion-richness heuristic fails while gradient-based attribution succeeds is a diagnostic validation of the entire framework: influence, as measured through model-specific gradients, captures something fundamentally different from data statistics.

What makes this intellectually distinctive is that it clarifies what "influence" means in the context of motion attribution. A training clip is influential not because it contains a lot of motion, but because its gradients align with the query's gradients — meaning that updating the model to better predict the training clip would also improve prediction on the query. This is the standard influence-function interpretation, but applied to a domain where the intuitive proxy (motion magnitude) is so salient that it would be easy to mistake correlation for causation. The paper's explicit analysis and ablation (comparing Motive against the motion-magnitude baseline) prevents this misinterpretation and establishes that gradient-based attribution provides information beyond what is visible in the data alone.

This finding also connects to a broader intellectual tension in the data-centric ML literature: the difference between data that looks relevant (high motion magnitude, high diversity, high quality scores) and data that actually improves the model when used for training. Motive provides a concrete case study of this distinction in a domain where it matters — motion quality in generated video — and demonstrates that gradient-based attribution can surface clips that a human curator or heuristic filter would not identify.

Innovation 4: Closing the Loop from Attribution to Actionable Data Curation

Attribution methods are often evaluated through proxy metrics — correlation with leave-one-out retraining, consistency across random seeds, or visual inspection of top-ranked examples. These evaluations establish that the attribution scores are meaningful, but they stop short of demonstrating that attribution enables better downstream outcomes. Motive closes this loop: the paper doesn't just show that Motive scores identify training clips relevant to query motions (Figures 2, 5), but that fine-tuning on Motive-selected data actually improves motion quality as measured by VBench metrics and human evaluation (Tables 1, 2).

This is a substantial intellectual contribution because it addresses the persistent "so what?" question that plagues attribution research. An attribution method that produces interpretable rankings but doesn't improve any downstream task is a scientific curiosity; a method that enables better data curation is an engineering tool. The paper's results — achieving higher Dynamic Degree (47.6%) and subject consistency (96.3%) than full-dataset fine-tuning (42.0% and 95.9%) using only 10% of the data — demonstrate that the attribution signal is not just interpretable but predictively useful. The 74.1% human preference win rate against the base model (Table 2) further validates that the improvements are perceptually meaningful, not just metric artifacts.

What elevates this beyond a standard "our method improves performance" claim is the specific pattern of results in Table 1. Motive improves Dynamic Degree substantially (47.6% vs. 41.3% random, 42.0% full fine-tuning) while maintaining or improving other metrics (subject consistency 96.3% vs. 95.3% base, motion smoothness 96.3% matching base). The motion magnitude baseline, by contrast, degrades motion smoothness (95.7%) and imaging quality (63.2%) while barely improving Dynamic Degree over the base model (40.1% vs. 39.6%). The V-JEPA embedding baseline trades off motion quality for dynamic degree improvement (motion smoothness drops to 95.6%, imaging quality to 62.7%). These patterns suggest that the Motive-selected data improves motion without the collateral damage to other qualities that naïve selection heuristics incur — a sign that the attribution signal is specifically capturing motion-relevant influence rather than generic data quality.

The paper's framing of this as a data curation pipeline rather than just an analysis tool is also significant. Appendix G.1 quantifies the cost structure: the expensive part (computing per-sample gradients, ~150 GPU-hours on a single A100 for 10k samples) is done once and amortized across all queries; adding a new query costs ~54 seconds. This cost profile makes the method practical for iterative curation workflows — compute gradients once, then repeatedly query against the stored representations for different motion targets. The paper doesn't just propose a method and evaluate it; it designs for a use case (data curation for fine-tuning) and demonstrates feasibility at meaningful scale.

5. Experimental Analysis

Evaluation Methodology

• Dataset. All experiments use the Wan2.1-T2V-1.3B model fine-tuned on two large-scale video datasets: VIDGEN-1M (Tan et al., 2024) and 4DNeX-10M (Chen et al., 2025). For the main experiments, 10k videos are sampled from each dataset to provide "sufficient scale and diversity to thoroughly evaluate motion attribution methods across different temporal patterns and video generation scenarios" (Section 4.1). The fine-tuning corpus $\mathcal{D}_{\text{ft}}$ therefore contains $N = 10,000$ video-conditioning pairs.

• Base model(s). The primary model is Wan2.1-T2V-1.3B, a widely-used open-source text-to-video flow-matching model with a DiT backbone. The paper argues this model is chosen for "strong performance and feasible compute" (Section 4.1). Additional results on Wan2.2-TI2V-5B (a larger 5B-parameter model with a higher-compression VAE) are reported in Appendix C.1, Table 5. All fine-tuning updates only the DiT backbone; the T5 text encoder and VAE are frozen throughout.

• Metrics. The primary evaluation benchmark is VBench (Huang et al., 2024), which computes scores across six dimensions: subject consistency, background consistency, motion smoothness, dynamic degree, aesthetic quality, and imaging quality. Motion smoothness and dynamic degree are the "primary targets for temporal dynamics, while other metrics ensure visual quality is maintained" (Section 4.1). All VBench scores are percentages (higher is better). Evaluation prompts follow VBench's descriptive style and are custom-designed for the 10 motion types studied (bounce, compress, explode, float, free fall, roll, slide, spin, stretch, swing), with 5 prompts per motion type. Human evaluation uses a pairwise comparison protocol: 17 annotators evaluate generated videos across 10 motion categories, with 5 test cases per category across three baseline pairings, yielding 850 total judgments. Annotators choose which video shows better motion; presentation order is randomized and ties are allowed. The paper reports win rate (fraction our method is preferred), tie rate, and loss rate (Table 2).

• Baselines. The paper compares against five baselines:

  1. Base model: the pretrained Wan2.1-T2V-1.3B without any fine-tuning.
  2. Full fine-tuning: fine-tuning on the complete dataset (all 10k clips), presented as an "approximate upper bound" (Section 4.1).
  3. Random selection: uniformly sampling 10% of the training data without replacement.
  4. Motion magnitude: selecting the 10% of videos with the highest average motion magnitude computed from optical flow. This tests whether simply selecting high-motion clips achieves comparable downstream benefits without gradient-based attribution.
  5. V-JEPA embeddings: selecting the 10% of videos whose self-supervised spatiotemporal features (extracted via V-JEPA, Assran et al., 2025) are most representative of motion patterns. This tests whether generic spatiotemporal representations can substitute for model-specific gradient signals.
  6. Ours without motion masking (w/o MM): the full Motive pipeline but using standard whole-video gradients (uniform weights, $\tilde{\mathbf{W}} = \mathbf{1}$ everywhere) rather than motion-weighted gradients. This is the critical ablation isolating whether the motion masking specifically improves over general video-level attribution.

• Generation budget / compute accounting. The "budget" in all experiments is the subset size $K$: all selection methods (random, motion magnitude, V-JEPA, Motive) select exactly 10% of the training data (~1,000 clips out of 10,000). Fine-tuning runs for 1 epoch with the dataset repeated 50 times (Section 4.1, Appendix F.1), keeping total training steps consistent across methods. The paper does not vary the subset size in main experiments; the 10% threshold is fixed. Computational costs for each method are separately reported in Table 7 (Appendix G.1) as wall-clock time on a single GPU, but these costs are not factored into the generation budget comparison — the experiments compare methods at equal subset sizes, not equal compute for attribution.

• Cross-validation / statistical protocol. The paper does not employ cross-validation for strategy selection (unlike the compute-optimal scaling paper). VBench scores are computed on a fixed test set of prompts (50 total: 10 motion categories × 5 prompts each). Human evaluation uses 17 annotators with randomized presentation order, and the paper reports raw win/tie/loss percentages without confidence intervals or statistical significance tests. The motion distribution analysis (Appendix D.1, Figure 6) uses the same 10k VIDGEN videos as both the attribution corpus and the analysis set — there is no held-out validation split for hyperparameter selection. The projection dimension $D' = 512$ and timestep $t_{\text{fix}} = 751$ were selected based on Spearman correlation with full-gradient rankings (Section 4.4), not through downstream fine-tuning validation.

---

Main Quantitative Results

VBench Evaluation: Attributed Data Outperforms Heuristic Selection and Full-Dataset Fine-Tuning

Table 1 reports the primary quantitative comparison across all six VBench dimensions. All selection methods use 10% of the training data except "Full fine-tuning" which uses the complete dataset.

Headline numbers (Table 1):

• Dynamic Degree: Motive achieves 47.6%, substantially outperforming random selection (41.3%), full fine-tuning (42.0%), motion-unaware attribution (Ours w/o MM, 43.8%), V-JEPA embeddings (41.6%), motion magnitude selection (40.1%), and the base model (39.6%).
• Subject Consistency: Motive achieves 96.3%, the highest among all methods, surpassing full fine-tuning (95.9%) and the base model (95.3%).
• Motion Smoothness: Motive matches the base model and full fine-tuning at 96.3%, while motion magnitude (95.7%) and V-JEPA (95.6%) degrade this metric.
• Aesthetic Quality: Motive achieves 46.0%, slightly above full fine-tuning (45.0%) and the base model (45.3%).
• Background Consistency: Motive achieves 96.1%, competitive with the base model (96.4%) and full fine-tuning (96.6%).
• Imaging Quality: Motive achieves 64.6%, close to the base model (65.7%) and notably higher than Ours w/o MM (63.2%) and V-JEPA (62.7%).

What makes these results striking is the reversal pattern on Dynamic Degree. Full fine-tuning on the complete 10k dataset improves Dynamic Degree from 39.6% (base) to 42.0% — a gain of 2.4 percentage points. Motive, using only 10% of that same data (~1,000 clips), achieves 47.6% — a gain of 8.0 percentage points over the base model and a 5.6-point advantage over full-dataset fine-tuning. This means the 90% of training data that Motive excludes is actually harmful to dynamic degree compared to keeping it — fine-tuning on everything dilutes the motion-relevant signal. The "Ours w/o MM" baseline (43.8%) confirms this interpretation: even without motion-specific masking, video-level gradient attribution selects better data than random (41.3%) but falls short of motion-aware selection (47.6%), isolating the contribution of the motion masks themselves.

A secondary pattern is the tradeoff behavior of heuristic baselines. Motion magnitude selection degrades Motion Smoothness from 96.3% (base) to 95.7% and Imaging Quality from 65.7% to 63.2% — suggesting that simply selecting high-motion clips introduces temporally noisy or low-quality data that harms generation. V-JEPA embeddings similarly degrade Motion Smoothness (95.6%) and Imaging Quality (62.7%). Motive avoids these degradations: its Motion Smoothness (96.3%) matches the base model, and its Imaging Quality (64.6%) recovers 1.4 points over the w/o MM variant. The paper does not discuss why motion masking helps Imaging Quality — this may reflect that static regions in high-motion clips often contain compression artifacts or low texture quality that motion masking downweights in the attribution signal, preventing their selection.

Human Evaluation: Perceptually Meaningful Improvements, Especially Against the Base Model

Headline numbers (Table 2):

• Motive vs. Base model: 74.1% win rate, 12.3% tie, 13.6% loss — a dominant preference.
• Motive vs. Random selection: 58.9% win rate, 12.1% tie, 29.0% loss — a clear but less dominant preference.
• Motive vs. Full fine-tuning: 53.1% win rate, 14.8% tie, 32.1% loss — a modest preference.
• Motive vs. Ours w/o MM: 46.9% win rate, 20.0% tie, 33.1% loss — essentially no preference (w/o MM is slightly preferred when considering loss rate alone).

Interpretation of the human evaluation pattern. The 74.1% win rate against the base model establishes that the improvements are perceptually obvious — annotators can readily distinguish and prefer Motive-fine-tuned videos. The 53.1% win rate against full fine-tuning is more modest but directionally consistent with the VBench results (Motive achieves higher Dynamic Degree than full fine-tuning). The 46.9% win rate against Ours w/o MM is interesting because it suggests that motion masking provides measurable quantitative gains on VBench (Dynamic Degree 47.6% vs. 43.8%) but the perceptual difference may be subtle enough that human annotators do not consistently prefer it. The paper does not report statistical significance tests, so the 53.1% vs. 46.9% differences relative to 50% chance should be interpreted cautiously, especially with only 17 annotators and 50 videos per comparison.

Where human evaluation aligns and diverges from VBench. The VBench Dynamic Degree metric shows Motive substantially outperforming Ours w/o MM (47.6% vs. 43.8%, a +3.8 point gap), but human annotators show a slight preference against Motive (46.9% win vs. 33.1% loss for w/o MM, meaning w/o MM wins 33.1% of the time vs. Motive's 46.9%). This discrepancy suggests that Dynamic Degree — which measures the average motion magnitude in generated videos — may not fully capture perceptual motion quality. Videos with higher Dynamic Degree scores might contain more motion but not necessarily better motion, and annotators may prefer videos with smoother or more realistic dynamics even if they are less dynamic by the metric. The paper does not discuss this tension between metric and human evaluation for the w/o MM comparison.

Cross-Model Generalization: Consistent Gains on a 5B-Parameter Model

Headline numbers (Table 5, Appendix C.1), Wan2.2-TI2V-5B:

• Dynamic Degree: Motive achieves 48.3%, compared to base model (42.0%), full fine-tuning (45.3%), random selection (41.6%), and Ours w/o MM (43.8%).
• Motion Smoothness: Motive achieves 97.6%, slightly above the base model and full fine-tuning (both 97.5%).
• Subject Consistency: Motive achieves 95.1%, competitive with full fine-tuning (95.3%) and the base model (94.9%).
• Background Consistency: Motive achieves 96.6%, the highest among all methods.

The pattern replicates: Motive achieves the highest Dynamic Degree (48.3% vs. 45.3% for full fine-tuning, a +3.0 point gap) while maintaining or exceeding base-model quality on all other metrics. Random selection degrades several metrics (Subject Consistency: 94.7% vs. 94.9% base; Motion Smoothness: 97.3% vs. 97.5% base), confirming that blind subset selection is not harmless. The Ours w/o MM baseline (Dynamic Degree: 43.8%) again falls between random selection and full Motive, isolating the contribution of motion masking.

The gain magnitude is consistent across model scales. On Wan2.1-T2V-1.3B, Motive improves Dynamic Degree by +5.6 points over full fine-tuning (47.6% vs. 42.0%). On Wan2.2-TI2V-5B, the improvement is +3.0 points (48.3% vs. 45.3%). The smaller relative gain on the larger model may reflect ceiling effects (the base model's Dynamic Degree is already 42.0% on Wan2.2 vs. 39.6% on Wan2.1) or differences in the training data distribution for the 5B model. The paper does not analyze this difference.

Qualitative Results: Motion Attribution Ranks Physically Grounded Dynamics Over Static or Stylized Content

Figure 2 shows top-ranked positive and negative training samples for two query motions (float and roll). Positive samples consistently show continuous, physically grounded trajectories: for floating (turbulent water carrying objects, planetary rotation), for rolling (objects with visible rotation axes, smooth translation across surfaces). Negative samples fall into two categories: (1) clips with minimal or camera-only motion — essentially static scenes that contribute no motion signal, and (2) clips with cartoon-style or simplified kinematics that do not transfer to realistic motion generation. The paper interprets these negatives as "data that dilutes temporal learning during fine-tuning" (Section 4.2).

Figure 3 provides qualitative comparisons of generated videos across four motion scenarios (compress, spin, slide, free fall). The paper claims that Motive-fine-tuned models produce "more realistic motion dynamics" and "higher motion fidelity and temporal consistency than both baselines, especially for complex deformation, rotational dynamics, and physics-driven motion" (Section 4.2). The qualitative examples are illustrative but limited — only 4 scenarios are shown, and the evaluation is subjective. The human evaluation (Table 2) provides a more systematic assessment.

Cross-Motion Influence Patterns: Physically Similar Motions Share Influential Training Data

Headline numbers (Figure 7, Appendix D.2), across both VIDGEN and 4DNEX datasets:

• Mean overlap of top-100 influential samples across motion categories: 24.0% (4DNEX) and 24.3% (VIDGEN), indicating moderate sharing.
• High-overlap pairs consistently identified across both datasets: bounce–float (44.4% / 46.3%), compress–float (40.1% / 34.0%), compress–spin (36.9% / 39.6%).
• Low-overlap pairs consistently identified: free fall–stretch (12.8% / 12.7%), float–slide (14.0% / 10.9%).

The interpretation offered by the paper is that high-overlap motions "share fundamental characteristics that the model learns from similar training examples" while low-overlap pairs "indicate more specialized influential data for mechanically dissimilar motions." The consistency of overlap patterns across two different datasets strengthens this interpretation — it suggests that the overlap reflects genuine kinematic similarity (objects that bounce also tend to float, objects that compress also spin) rather than dataset-specific artifacts.

The asymmetric nature of the overlap matrices is noted but not deeply analyzed. The paper states that asymmetry "arises because different motion categories have different numbers of unique influential videos, leading to directional overlap percentages." For example, bounce → float overlap (44.4%) differs from float → bounce overlap because the number of top-100 influential samples that are unique to bounce differs from the number unique to float. This is a property of the majority-vote aggregation and the fact that different motion categories have different "footprints" in the training data.

Motion Distribution Analysis: High-Influence Clips Do NOT Have Higher Average Motion

Headline numbers (Figure 6, Appendix D.1):

• Mean motion magnitude of top 10% (highest influence): 3.85.
• Mean motion magnitude of bottom 10% (lowest influence): 3.69.
• Difference: only 4.3%, despite representing opposite extremes of influence scores.
• Distribution overlap: high-influence and low-influence videos both appear in low-motion bins (0–2) and high-motion bins (6–9). Within moderate-motion bins (3, 4, 5), top-10% samples outnumber bottom-10% samples, but both groups are present.

The paper interprets this as evidence that "Motive is not simply selecting 'motion-rich' clips" and that "our motion attribution approach captures training influence, focusing on motion rather than simply acting as a motion-saliency filter." This is a critical validity check: if high-influence clips simply had higher average motion magnitude, then the entire gradient-based pipeline would be reducible to a cheap motion-magnitude filter. The near-identical means (3.85 vs. 3.69) and the substantial distributional overlap refute this alternative explanation.

---

Ablation Studies and Robustness Checks

Single-timestep attribution (Section 4.4): Using a single fixed timestep $t_{\text{fix}} = 751$ (midpoint of the 1000-step denoising trajectory) achieves $\rho = 66\%$ Spearman correlation with the "ground truth" influence rankings computed using 10 evenly-spaced timesteps sampled according to the flow matching schedule. The paper argues that averaging multiple timesteps yields "minimal ranking gains" and that "incorporating late-timestep gradients can bias rankings" because late denoising steps operate on nearly formed videos where gradients reflect fine details rather than semantic motion structure. Early timesteps (high noise) obscure motion cues. The midpoint at $t=751$ represents a balance. This is a one-dimensional ablation over a single variable (timestep choice) with correlation to a multi-timestep baseline as the metric — it does not validate the choice through downstream fine-tuning performance.

Projected gradient dimension (Section 4.4, Figure 4): Spearman correlation between projected and full-gradient influence rankings improves with projection dimension: $D' = 128$ yields $\rho = 46.9\%$, $D' = 512$ yields $\rho = 74.7\%$, $D' = 1024$ yields $\rho = 75.7\%$, $D' = 2048$ yields $\rho = 76.1\%$. The paper selects $D' = 512$ as the knee in the tradeoff curve, arguing that beyond this point "gains are marginal while cost rises." This ablation is performed against full-gradient rankings (not against downstream fine-tuning outcomes), and the correlation metric is Spearman's $\rho$ over rankings of training examples.

Frame-length normalization (Section 4.4, Figure 5): Without frame-length normalization (Eq. 11), gradient-based influence scores correlate with video length at $\rho = 78.0\%$ (Spearman correlation between influence score and clip duration). With normalization, the paper reports that spurious length correlations are "reduced by 54.0% while preserving motion-based correlation." Figure 5 provides a qualitative visualization for a "float" motion query: with normalization, top-ranked samples consistently show wave dynamics, floating objects, and surfing; without normalization, top samples "lack coherent similarity because rankings are driven by clip length." The ablation validates the necessity of the $1/F$ correction factor.

Motion masking vs. no masking (Table 1, "Ours w/o MM" baseline): The motion-unaware variant of Motive (using uniform weights, $\tilde{\mathbf{W}} = \mathbf{1}$, equivalent to whole-video attribution) achieves Dynamic Degree 43.8% versus 47.6% for full Motive — a +3.8 percentage point gap attributable to the motion masks. Other metrics show mixed effects: Subject Consistency improves slightly (96.3% vs. 95.4%), Aesthetic Quality improves (46.0% vs. 45.7%), but Background Consistency is slightly lower (96.1% vs. 96.1% — identical, though the paper reports different values in the table), and Imaging Quality improves substantially (64.6% vs. 63.2%). This is the critical ablation establishing that motion-specific reweighting provides gains beyond general video-level attribution.

Motion magnitude baseline vs. Motive (Table 1): Selecting the 10% of clips with highest average motion magnitude achieves Dynamic Degree 40.1% — barely above the base model (39.6%) and far below Motive (47.6%). Motion magnitude selection also degrades Motion Smoothness (95.7% vs. 96.3% base) and Imaging Quality (63.2% vs. 65.7% base). This ablation establishes that motion-richness alone does not explain Motive's gains and that the gradient-based attribution signal captures qualitatively different information from raw motion statistics.

V-JEPA embedding baseline vs. Motive (Table 1): Using self-supervised spatiotemporal features from a pretrained V-JEPA model to select representative clips achieves Dynamic Degree 41.6% — better than motion magnitude (40.1%) but far below Motive (47.6%). V-JEPA also degrades Motion Smoothness (95.6%) and Imaging Quality (62.7%). This ablation establishes that generic spatiotemporal representations, even from a state-of-the-art self-supervised model, do not capture the model-specific influence signal that gradient-based attribution provides.

Full fine-tuning baseline (Table 1): Fine-tuning on the complete 10k dataset achieves Dynamic Degree 42.0%, higher than the base model (39.6%) but substantially lower than Motive with 10% of the data (47.6%). This is not an ablation in the traditional sense but establishes the counterintuitive result that "more data is not better" for motion quality — the majority of the training data is either irrelevant or actively harmful to dynamic degree, and selective curation outperforms exhaustive inclusion.

---

Critical Assessment

Claim 1: "Motive identifies clips that strongly affect motion and guides data curation that improves temporal consistency and physical plausibility"

Assessment: Directly supported by Table 1 and Table 2. The Dynamic Degree improvement from 39.6% (base) to 47.6% (Motive) is substantial, and the human evaluation win rate of 74.1% against the base model confirms perceptual improvements. However, the claim conflates two distinct things: (1) Motive identifies influential clips, and (2) fine-tuning on those clips improves motion. The experiments demonstrate (2) — the downstream fine-tuning outcome. They provide indirect evidence for (1) through the qualitative ranking examples (Figures 2, 5), the motion distribution analysis showing that Motive does not simply select high-motion clips (Figure 6), and the cross-motion overlap patterns that align with physical similarity (Figure 7). But the paper does not run the most direct test of attribution quality: taking the top-ranked clips, actually removing them from the training set, and measuring whether motion quality degrades more than when removing random clips. This "leave-influential-out" counterfactual experiment is standard in the data attribution literature (e.g., Koh & Liang, 2017; Park et al., 2023) but is absent here. The motion-unaware ablation ("Ours w/o MM") partially addresses this by showing that motion masking specifically improves downstream outcomes, but it does not directly validate that individual top-ranked clips are more influential than randomly selected clips — it only validates that the method's selections as a set are better.

What would strengthen this claim: A counterfactual experiment that removes the top-K most positively influential clips and demonstrates a drop in motion quality relative to removing random clips. Or, conversely, an experiment that shows a dose-response relationship: fine-tuning on top-1%, top-5%, top-10%, top-25% of clips ranked by Motive and showing monotonic improvement in Dynamic Degree up to some optimal subset size. The current experiments only evaluate a single subset size (10%).

Claim 2: "Our method improves both motion smoothness and dynamic degree on VBench, achieving a 74.1% human preference win rate compared with the pretrained base model."

Assessment: The VBench claim is partially supported. Dynamic Degree improves substantially (47.6% vs. 39.6% base, Table 1). Motion smoothness is maintained at 96.3% (matching the base model), not improved. This is a meaningful result — maintaining smoothness while increasing dynamic degree is non-trivial, as the motion magnitude and V-JEPA baselines both show (they degrade smoothness while barely improving dynamic degree). The human preference claim is directly supported by Table 2. However, the motion smoothness result highlights a subtle tension: Motive improves how much motion occurs (Dynamic Degree) but does not improve how coherent that motion is (Motion Smoothness) beyond the base-model baseline. The paper could have framed this as "improves dynamic degree without sacrificing smoothness" but instead claims "improves both motion smoothness and dynamic degree," which overstates the smoothness result relative to the base model (96.3% vs. 96.3% — identical).

Claim 3: "Motive... matching, or surpassing, full-dataset fine-tuning performance with only 10% of the data."

Assessment: Supported with nuance. On Dynamic Degree, Motive (47.6%) substantially surpasses full fine-tuning (42.0%) — a +5.6 point gap. On Subject Consistency, Motive (96.3%) slightly surpasses full fine-tuning (95.9%). On Motion Smoothness, both tie at 96.3%. On Aesthetic Quality, Motive (46.0%) surpasses full fine-tuning (45.0%). On Background Consistency, full fine-tuning (96.6%) surpasses Motive (96.1%). On Imaging Quality, Motive (64.6%) surpasses full fine-tuning (63.9%). So the "matching or surpassing" claim holds on 5 of 6 metrics (the exception being Background Consistency, where full fine-tuning has a narrow 0.5-point edge). The claim is well-supported by the data but the paper does not discuss why full fine-tuning underperforms — specifically, whether the excluded 90% of data contains clips that are actively harmful (negative influence) or simply irrelevant (zero influence). The Motion Smoothness parity (96.3% for both) suggests that the excluded data does not contain motion-smoothing-relevant signal, while the Dynamic Degree gap (42.0% vs. 47.6%) suggests the excluded data actively reduces dynamic motion — consistent with the negative-influence interpretation but not proven by the available experiments.

Claim 4: "Outperforming motion-unaware attribution baselines."

Assessment: Supported. "Ours w/o MM" achieves Dynamic Degree 43.8% vs. 47.6% for full Motive (Table 1) — a clear gap attributable to motion masking. However, the human evaluation (Table 2) complicates this: Motive vs. w/o MM shows a 46.9% win rate with 33.1% loss and 20.0% tie — meaning annotators do not consistently prefer the motion-masked variant, and in fact w/o MM "wins" a non-trivial fraction of comparisons. This suggests that the VBench Dynamic Degree advantage of motion masking (+3.8 points) may not translate cleanly to perceptual preference, possibly because the motion-unaware variant selects clips that improve other aspects of generation quality (it achieves higher Background Consistency at 96.1% vs. Motive's 96.1% — identical in the table — and the human evaluators may weight different attributes than the VBench metric). This is a genuine tension in the results that the paper does not address.

Genuine Weaknesses in the Experimental Design

• Single subset size (10%): All experiments use exactly 10% of the training data. There is no sweep over subset sizes to establish a dose-response curve or to identify whether 10% is near-optimal or arbitrary. If Motive's advantage over random selection is largest at small subset sizes (e.g., top 1%) and diminishes as more data is included, that would strengthen the claim that attribution identifies the most influential clips. The paper does not test this.

• Single model family for ablation and main results: The main experiments (Tables 1, 2) use Wan2.1-T2V-1.3B. Wan2.2-TI2V-5B results are reported in Appendix C.1 (Table 5) but are treated as supplemental rather than core validation. The motion distribution analysis (Figure 6), cross-motion influence patterns (Figure 7), and all ablations (timestep choice, projection dimension, frame-length normalization) are performed on Wan2.1 only. The cross-model results in Table 5 show the same qualitative pattern but are not ablated — we do not know whether the optimal timestep or projection dimension differs for the 5B model.

• Query set is synthetic and limited in diversity: The 50 query videos are generated by Veo-3 with carefully controlled prompts designed to isolate specific motion primitives against clean backgrounds. This is methodologically sound for establishing feasibility but limits the ecological validity of the results. Real-world motion queries would involve cluttered scenes, multiple simultaneous motions, camera movement, and complex object interactions — all of which would challenge the per-pixel motion masking approach. The paper does not test on natural video queries.

• No negative influence validation: The paper shows examples of "negative influence samples" in Figure 2 (static footage, camera-only motion, cartoon-style content) but does not run an experiment that verifies these are genuinely harmful — e.g., taking the bottom-ranked clips (most negative influence) and showing that fine-tuning on them degrades motion quality below the base model. This would validate that Motive identifies not just irrelevant but harmful data.

• No confidence intervals or statistical tests: VBench scores in Table 1 are reported as point estimates without error bars or confidence intervals. Human evaluation win rates in Table 2 are reported without statistical significance tests, despite the modest sample size (17 annotators, 50 videos per comparison). The 53.1% win rate against full fine-tuning and 46.9% win rate against w/o MM could be statistically indistinguishable from 50% given the sample size — the paper does not provide the information needed to assess this.

• Computational cost of baselines not equalized: The attribution computation for Motive costs ~150 GPU-hours on a single A100 for 10k samples (Table 7). The baselines (motion magnitude: ~5.5 hours, V-JEPA: ~3 hours) are substantially cheaper. The experiments compare at equal subset size (10%) but not at equal compute budget for attribution + fine-tuning. A fairer comparison might ask: if Motive uses 10% of the data but costs 150 GPU-hours for attribution, what if random selection used 50% of the data (since it costs <1 second for attribution) — would the larger random subset match Motive's performance? This experiment is not run.

• No comparison to influence-function baselines from the image domain applied naïvely to video: The paper compares against motion magnitude and V-JEPA as heuristic baselines, and against itself without motion masking (w/o MM) as an attribution baseline. It does not compare against a direct port of Diffusion-ReTrac (Xie et al., 2024) or TRAK (Park et al., 2023) applied to whole videos without motion-specific modifications. The w/o MM baseline is similar in spirit to Diffusion-ReTrac (gradient similarity with single timestep and projection, no motion masking), but the paper does not cite or configure it as such, making it unclear whether the w/o MM variant matches prior art.

• The 10% threshold for majority voting is not ablated: The percentile cutoff $\tau$ in Eq. 18 is not specified in the main text or analyzed. Different values of $\tau$ would change which training clips receive votes from each query, potentially altering the composition of the selected subset. The paper does not report sensitivity to this hyperparameter.

Experiments That Would Have Strengthened the Paper

1. Leave-influential-out counterfactual: Remove the top-$K$ Motive-ranked clips from the training set, fine-tune on the remainder, and measure degradation in Dynamic Degree relative to removing random clips. This is the gold-standard evaluation for data attribution methods and its absence is the most significant gap.

2. Subset-size sweep: Evaluate Dynamic Degree at top-1%, 5%, 10%, 25%, 50%, 100% of data selected by Motive vs. random selection. A dose-response curve showing that Motive achieves near-optimal performance at smaller subsets would strengthen the efficiency claim.

3. Negative-influence fine-tuning experiment: Fine-tune on the bottom-ranked clips and demonstrate that Dynamic Degree drops below the base model, validating that Motive identifies genuinely harmful data, not just irrelevant data.

4. Ablation of the motion tracker: Compare Motive using AllTracker vs. RAFT vs. a simpler optical flow method. The paper claims tracker-agnosticism (Appendix E) but does not validate it empirically.

5. Natural video queries: Test Motive on a held-out set of real videos (not synthetic Veo-3 outputs) to assess robustness to cluttered scenes, camera motion, and multi-object dynamics.

6. Compute-equalized baselines: Allow random selection to use more data (compensating for its cheaper attribution) and see whether the performance gap closes.

7. Statistical significance for human evaluation: Report confidence intervals or p-values for the win rates in Table 2, especially the close comparisons (53.1% vs. full FT, 46.9% vs. w/o MM).

8. Fine-tuning on single-motion-category selected data (specialist models): The paper mentions training specialists (Section 4.1) but does not report their VBench performance separately from the generalist model in Table 1. Comparing specialist vs. generalist would test whether cross-motion data sharing (Figure 7) is beneficial or harmful.

6. Limitations and Trade-offs

The Difficulty Estimation Cost Is Not Amortized in the Headline Efficiency Numbers

The assumption or constraint. The entire compute-optimal framework depends on estimating prompt difficulty before allocating the inference budget. The method for doing so — generating 2048 samples per question and averaging PRM final-answer scores into five difficulty quintiles — is immensely expensive: 2048 generations per question before any problem-solving budget is spent. The authors acknowledge this explicitly in Section 3.2:

"estimating difficulty in this way still incurs additional computation cost during inference... our experiments do not account for this cost largely for simplicity"

The consequence. The reported 4× efficiency gains (e.g., matching best-of-64 performance with only 16 generations in Figure 4) are computed after difficulty is already known, without amortizing the cost of obtaining that knowledge. For a single question, the true cost is difficulty estimation (2048 generations) + strategy execution (the reported budget). Since the difficulty estimation alone consumes 4–8× more compute than the largest budgets studied (256–512 generations), the practical efficiency gain in a single-question deployment could be negative — the total cost would exceed simply running best-of-512 on every problem. This makes the headline 4× figure an upper bound on achievable efficiency, not a realized deployment gain.

What evidence exists in the paper. The cost asymmetry is visible in the experimental setup itself (Section 3.2): difficulty estimation uses 2048 samples to bin questions, while the compute-optimal strategies operate at 4–256 generation budgets. The paper does not report total FLOPs or wall-clock comparisons that include difficulty estimation. The predicted (non-oracle) difficulty bins perform nearly as well as oracle bins (Figure 4 curves largely overlap), which is encouraging for label-free deployment, but the computational cost of predicted bins is identical to oracle bins — both require the full 2048-sample sweep through the PRM.

Mitigation status. The paper explicitly flags this as a key avenue for future work: "pretraining or finetuning models to directly predict difficulty of a question" (Section 8). An adaptive approach — starting with a few samples, assessing score distribution, and allocating accordingly — is mentioned as an alternative but not developed or evaluated. Until lightweight difficulty estimation is demonstrated, the framework is an analytical contribution (showing what is possible) rather than a deployable system.

---

The Hardest Problems Remain Fundamentally Unsolved

The assumption or constraint. Test-time compute can only improve performance on problems where the base model has a non-negligible chance of producing a correct answer. If the base model's pass@1 is near zero, no search or revision strategy can help — there are no correct solutions in the proposal distribution to find. The paper is explicit about this boundary (Section 7 takeaway):

test-time compute amplifies existing capability but does not create it from nothing.

The consequence. Across all methods and all budgets, difficulty bin 5 (the hardest quintile) shows near-zero improvement. In Figure 3 (right), bin 5 accuracy hovers at 1–3% for beam search and best-of-N at all budgets from 4 to 256 generations. In Figure 7 (right), bin 5 accuracy is roughly 2–3% regardless of the sequential-to-parallel ratio. In the FLOPs-matched comparison (Figure 9), the bin 5 scaling line is essentially flat near 0–5% for all three values of R. The framework provides no path forward for genuinely novel or out-of-distribution reasoning that exceeds the base model's training distribution. For such problems, pretraining a larger model remains the only viable approach — test-time compute is not a substitute.

What evidence exists in the paper. The bin 5 flatlines are consistent across every experiment: search (Figure 3 right), revisions (Figure 7 right), FLOPs-matched comparisons (Figure 9), and compute-optimal variants (Figures 4, 8). The paper is candid about this limitation, but the implication is that the method's practical utility is restricted to problem distributions where the base model already has non-trivial capability — a significant scope constraint for practitioners considering deployment.

Mitigation status. No mitigation is proposed, and the paper treats this as a fundamental boundary rather than a solvable technical limitation. Section 8 does not suggest approaches for hard problems. The finding is valuable as a characterization of when test-time compute is useful, but it means the method cannot expand the frontier of what models can solve — it can only exploit existing capability more efficiently.

---

The 14× Larger Model Baseline Is Not Compute-Optimally Trained

The assumption or constraint. The FLOPs-matched comparison in Section 7 scales only model parameters when increasing pretraining compute, holding training data fixed. This follows the LLaMA paradigm (Touvron et al., 2023) rather than the Chinchilla-optimal paradigm (Hoffmann et al., 2022), where both data and parameters are scaled to maximize performance per FLOP. The authors acknowledge this:

"We choose this setting as it is representative of a canonical approach to scaling pretraining compute and leave the analysis of compute-optimal scaling of pretraining compute where the data and parameters are both scaled equally to future work."

The consequence. A Chinchilla-optimal model trained with 14× more total FLOPs (scaling both parameters and training tokens) would likely outperform the parameter-only-scaled model used as the baseline. This means the reported advantages of test-time compute over pretraining — e.g., +27.8% relative improvement on easy questions at R ≪ 1 for revisions (Figure 1, top-right bar chart) — are measured against a baseline that is weaker than what compute-optimal training would produce. The paper cannot distinguish whether test-time compute genuinely outperforms compute-optimal pretraining or merely outperforms a suboptimal pretraining allocation. This weakens the paper's central claim about the training-inference tradeoff.

Additionally, the 14× larger model uses only greedy decoding with no test-time augmentation of its own. Giving the larger model even a modest test-time compute budget (e.g., best-of-8 or majority voting over 4 samples) would create a substantially stronger baseline. The comparison is therefore not just "small model + test-time compute vs. large model" but "small model + optimized test-time compute vs. large model with no test-time compute" — an asymmetric setup that overstates the advantage of the proposed approach.

What evidence exists in the paper. Figure 9 and the bar charts in Figure 1 show the FLOPs-matched results. The gap between test-time compute and pretraining narrows substantially as R increases and as difficulty increases, but the underlying weakness of the baseline is not quantified — we don't know whether a compute-optimally trained 14× larger model would close or eliminate the gap entirely, because such a model is not evaluated.

Mitigation status. The paper acknowledges this limitation explicitly and frames the LLaMA-style scaling as "representative." Future work on compute-optimal pretraining baselines is suggested in Section 8. No sensitivity analysis is provided (e.g., varying the pretraining data-to-parameters ratio to see how the tradeoff changes).

---

The Revision Model and PRM Search Are Never Combined

The assumption or constraint. The paper studies two complementary mechanisms — PRM-guided search (beam search, lookahead search, best-of-N) and iterative revisions — as independent scaling axes. Section 8 explicitly acknowledges they were not combined:

"we did not experiment with PRM tree-search techniques in combination with revisions"

The consequence. The paper demonstrates that revisions improve the proposal distribution (better candidates through iterative refinement) and that PRM search improves candidate selection (finding the best among generated candidates). These strengths are complementary: revisions are most effective on easy problems (local refinement of already-correct answers), while search is most effective on medium problems (global exploration of solution strategies). Combining them — e.g., using the revision model as the proposal distribution within beam search, or using the PRM to decide when to revise versus restart — could yield gains beyond either mechanism alone. The current results therefore represent a lower bound on what a fully integrated system could achieve. Practitioners wanting to deploy both mechanisms would need to design the integration themselves without guidance from this paper.

What evidence exists in the paper. The difficulty-dependent behavior in Figures 3 (right) and 7 (right) shows the complementary patterns: revisions dominate on easy problems, search on medium problems. No experiment tests the combination. The compute-optimal policy selects between search and revisions per problem, but never combines them on the same problem.

Mitigation status. The paper identifies this as a natural next step but does not explore it. The absence is understandable given the paper's scope (a systematic scaling analysis of individual mechanisms), but it leaves open the question of whether the $4\times$ efficiency gains from compute-optimal allocation could be further improved by hybrid strategies.

---

Single Benchmark, Single Model Family Limits Generality

The assumption or constraint. All experiments — search, revisions, FLOPs-matched comparisons, and ablations — use the MATH benchmark (500 test questions) with PaLM 2-S* as the base model. The authors state they "believe this model is representative of the capabilities of many contemporary LLMs" (Section 4), but this claim is unverified across model families, scales, or problem domains.

The consequence. Several aspects of the findings could be model-specific or benchmark-specific:

• The PRM's over-optimization behavior (beam search degrading easy-problem performance at high budgets, Figure 3 right) depends on PaLM 2-S*'s output distribution and the PRM's calibration properties. A model with different error patterns or a PRM trained with different data might exhibit different difficulty-dependent scaling curves.
• The revision model's ability to learn from incorrect in-context examples depends on the base model's in-context learning capabilities, which vary substantially across model families (some models are better at following revision-style prompts than others).
• MATH consists exclusively of competition-level math problems requiring symbolic reasoning. The difficulty-dependent patterns (beam search hurting easy problems, sequential revisions helping easy problems) may not generalize to code generation (where unit tests provide strong verifier signals), logical reasoning, or open-ended tasks without ground-truth correctness.
• The PRM training procedure (Monte Carlo rollouts from PaLM 2-S*) may not transfer to other model families where the rollouts have different quality or diversity characteristics. The paper's finding that the PRM800k dataset was "largely ineffective" for PaLM 2 models (Section 5.1) illustrates this sensitivity.

What evidence exists in the paper. No cross-model or cross-benchmark experiments are reported. The test set of 500 questions, split into five difficulty quintiles of ~100 each, then further split by two-fold cross-validation, means the compute-optimal policy is selected based on ~50 questions per fold per bin — a small sample that introduces variance in strategy selection. The paper does not report confidence intervals on the compute-optimal scaling curves, making it difficult to assess whether the observed $4\times$ efficiency gains are statistically reliable or would replicate on different test sets.

Mitigation status. The authors acknowledge the single-benchmark limitation but argue the model is "representative" — a claim that cannot be verified within the paper's scope. No replication experiments are proposed as future work. The small test set limitation is not discussed, and no confidence intervals are provided for any of the main results.

---

Sequential Revisions Introduce Latency That Is Not Accounted For

The assumption or constraint. The paper measures compute in "generations" (number of complete solutions sampled), which is a reasonable proxy for total FLOPs but ignores wall-clock time. Sequential revisions are inherently serial — each revision depends on the output of the previous one — while parallel best-of-N can be executed simultaneously given sufficient hardware. The paper's compute-optimal policy frequently favors sequential-heavy allocations (e.g., purely sequential revisions on easy problems, as shown in Figure 7 right for bins 1–2).

The consequence. A strategy that allocates 128 generations as 16 sequential × 8 parallel chains takes approximately 16× longer wall-clock time than one that runs 128 parallel samples simultaneously, even though both use the same total FLOPs. For latency-sensitive applications — interactive assistants, real-time decision-making, user-facing chatbots — the sequential-heavy strategies favored by the compute-optimal policy on easy and medium problems may be impractical regardless of their accuracy advantages. The paper's efficiency claims (4× fewer generations) could translate to worse latency in deployment, depending on the parallelism available.

What evidence exists in the paper. Figure 7 shows the optimal sequential-to-parallel ratio for different difficulty levels. On easy problems (bins 1–2), the optimal ratio is heavily skewed toward sequential (fully sequential or high sequential-to-parallel ratios). On medium problems (bins 3–4), a balanced ratio is optimal. The paper does not report wall-clock time, latency measurements, or throughput numbers for any strategy. The generation budget $N$ is treated as the sole cost metric throughout.

Mitigation status. This tradeoff is not discussed in Section 7 (Limitations) or anywhere in the main text. The compute-optimal framework as presented optimizes for accuracy per FLOP, not accuracy per second. In practice, a deployment system would need to incorporate a latency constraint — e.g., a maximum acceptable wall-clock time per query — which would change the optimal allocation strategy, potentially ruling out the purely sequential strategies that the paper's policy recommends for easy problems.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper establishes motion attribution as a distinct and legitimate category of data attribution, creating a conceptual framework where none existed before. This is not an incremental extension of image-domain attribution to videos — it is a reframing of what attribution means when the target of interest is not what a model produces but how it produces it across time. Before Motive, the field had no name for the problem of tracing generated motion back to training data, no method for doing so, and no evidence that such tracing could yield actionable improvements. The paper supplies all three.

A new diagnostic primitive for video generation. The methodological shift is from treating attribution as an analysis of model outputs (classification decisions, generated images, semantic concepts) to treating it as an analysis of model behavior — specifically, temporal dynamics that emerge across frames. This matters because it opens attribution to a category of model properties that are not captured by single outputs. Motion smoothness, physical plausibility, trajectory coherence, object interactions — these are properties of sequences, not of individual frames, and they cannot be diagnosed by examining which training images a model memorized. Motive provides the first tool for quantifying which training clips shape which motion patterns in generated video, and Table 1 demonstrates that this diagnostic signal is predictively useful: fine-tuning on Motive-selected data improves Dynamic Degree from 39.6% to 47.6%, while the motion-unaware attribution baseline reaches only 43.8%. This 3.8-point gap attributable specifically to the motion masks establishes that the motion attribution signal captures information that general video-level attribution misses — information that translates directly to better downstream generation.

Reconciling a hidden tension in data curation for video models. The paper resolves a practical tension that video generation practitioners face but that the literature had not articulated. On one hand, scaling training data improves video generation quality broadly — larger datasets correlate with better motion synthesis (Ho et al., 2022; Blattmann et al., 2023). On the other hand, the paper's results in Table 1 show that including all available data can actively harm specific motion qualities: full-dataset fine-tuning achieves Dynamic Degree 42.0%, while Motive-selected 10% subsets achieve 47.6%. The 90% of data that Motive excludes is, in aggregate, degrading dynamic degree below what targeted selection achieves. The resolution is that training data contains both positive-influence clips (those whose gradients align with desired motion patterns, improving the model's ability to generate those patterns) and negative-influence clips (those with irrelevant, contradictory, or noisy motion signals that dilute temporal learning). Motive's gradient-based scoring separates these categories without requiring manual inspection, and the motion distribution analysis in Appendix D.1 (Figure 6) — showing that high-influence and low-influence clips have nearly identical average motion magnitudes (3.85 vs. 3.69) — confirms that the separation is not reducible to a simple motion-richness filter. This reframes data curation from "collect more diverse data" to "select data that specifically improves target behaviors," with attribution providing the selection signal.

Verifier over-optimization as a first-class phenomenon in test-time scaling. The paper identifies and empirically characterizes verifier over-optimization as the primary bottleneck preventing unbounded improvements from additional compute. The evidence is concrete: beam search degrades easy-problem performance at high budgets (Figure 3, right), lookahead search — the most powerful optimizer — paradoxically performs worst overall (Figure 3, left), and Appendix M shows search producing degenerate outputs (repetitive low-information steps, overly short solutions) that score highly under the PRM. This shifts the narrative around test-time compute from "more is better" to "more is better only up to the verifier's reliability frontier," and it redirects research attention: rather than developing more sophisticated search algorithms (which the paper shows can be counterproductive), the priority should be building more robust verifiers resistant to over-optimization. The compute-optimal policy can be understood partly as a mechanism for staying below the over-optimization threshold per difficulty level — using weaker optimization (best-of-N) where the verifier is reliable and stronger optimization (beam search) only where the verifier signal has enough headroom to provide genuine guidance.

Making data attribution practically actionable. Data attribution methods have historically struggled with the "so what?" problem: they produce influence rankings that are interpretable and sometimes correlate with leave-one-out retraining, but they rarely demonstrate that acting on those rankings improves any downstream task. Motive closes this loop. The paper does not just show that Motive scores identify training clips relevant to query motions (Figures 2, 5) — it shows that fine-tuning on Motive-selected data produces videos that human annotators prefer 74.1% of the time over the base model (Table 2) and that match or surpass full-dataset fine-tuning across five of six VBench metrics using only 10% of the data (Table 1). This transitions attribution from an analysis tool to a data curation pipeline, and the cost analysis in Appendix G.1 (150 GPU-hours for one-time gradient precomputation on 10k samples, amortized across all future queries, with each new query costing ~54 seconds) demonstrates that the pipeline is practical at meaningful scale.

Which research directions become more attractive, and which become less so. The paper makes architectural modifications for motion modeling (temporal attention, flow guidance, consistency distillation) less attractive as the primary lever for improving motion quality — not because they are ineffective, but because the paper demonstrates that data curation can achieve substantial gains without any architectural changes. Conversely, the paper makes work on lightweight difficulty estimation (for compute-optimal allocation) and robust verifier training (to combat over-optimization) substantially more attractive, because the paper identifies these as the key bottlenecks preventing deployment of the framework it analyzes. The paper also makes self-improvement pipelines more attractive: the compute-optimal framework provides a principled way to allocate test-time compute during data generation for bootstrapping, and the difficulty-conditioned policy prevents wasting compute on problems where the base model has no chance of producing correct answers.

Follow-Up Research This Work Enables

Joint optimization of pretraining and inference compute allocation under a total FLOPs constraint. The paper studies the pretraining-inference tradeoff with a fixed, parameter-only-scaled pretraining baseline (Section 7) and acknowledges that compute-optimal pretraining (scaling both parameters and data per Hoffmann et al., 2022) would produce a stronger baseline. A complete picture would jointly optimize the pretraining recipe (model size, data quantity, data mixture) and the inference strategy (search method, revision depth, difficulty-conditioned allocation) under a single total FLOPs constraint. This is a substantially harder optimization problem — the pretraining and inference decisions interact because the base model's capability distribution determines which difficulty-dependent strategies are optimal — but it is the natural endpoint of the research direction this paper initiates. A strong follow-up would: (a) train a family of Chinchilla-optimal models at different compute scales, (b) characterize each model's difficulty-dependent test-time scaling curves using the paper's methodology, and (c) solve for the joint optimum numerically, reporting the fraction of total FLOPs that should be allocated to inference as a function of the total budget and the problem distribution. This would extend the paper's conceptual parallel to pretraining scaling laws (Hoffmann et al., 2022) into a unified framework.

Cheap difficulty estimation via lightweight classifiers or adaptive sampling. The most immediate bottleneck the paper identifies is the cost of difficulty estimation: the current method (2048 samples + PRM scoring per question, Section 3.2) consumes more compute than the largest inference budgets studied, making the $4\times$ efficiency gains unrealizable in deployment. The paper explicitly calls for "pretraining or finetuning models to directly predict difficulty of a question" (Section 8). A strong follow-up would: (a) train a lightweight classifier — possibly distilled from the PRM or trained on the PRM's average score distribution — that takes only the question text as input and predicts the difficulty bin, (b) measure the accuracy of this classifier against the oracle (2048-sample) difficulty bins on a held-out set, and (c) run the full compute-optimal pipeline using predicted difficulty from the classifier, comparing the resulting accuracy-efficiency curve to the oracle-based curve in Figures 4 and 8. If the classifier achieves even 80% bin accuracy, the efficiency gains should largely be preserved. A complementary approach is adaptive difficulty estimation: start by generating a small number of samples (e.g., 4–8), use the verifier's score distribution on those samples as a quick difficulty signal, and allocate the remaining budget accordingly, possibly with a bandit-style exploration component for the first few samples. This amortizes difficulty estimation into the problem-solving process itself and avoids the 2048-sample upfront cost entirely.

Combining PRM search with the revision model as the proposal distribution. The paper studies search and revisions independently and explicitly acknowledges they were not combined (Section 8). The difficulty-dependent analysis (Figures 3 right, 7 right) shows complementary strengths: revisions dominate on easy problems (local refinement of roughly-correct answers), while beam search dominates on medium problems (global exploration of solution strategies). A natural extension would use the revision model as the proposal distribution within beam search: at each step of the search tree, the model conditions on previous rejected branches as context, generating higher-quality candidate steps than the base model would produce independently. The PRM would score partial solutions, and the search would navigate the expanded space of revision-conditioned proposals. A strong follow-up would: (a) implement revision-augmented beam search and compare it against standalone beam search and standalone revisions at matched generation budgets, (b) measure whether the combined approach shifts the difficulty-dependent optimal strategy — specifically, whether search+revisions on medium problems achieves gains beyond what either mechanism achieves alone, and (c) test whether the revision model's known failure mode (38% correct-to-incorrect reversion rate, Section 6.1) is mitigated by PRM guidance that can detect when a revision has gone off-track and backtrack. This experiment directly addresses the paper's identified limitation and could determine whether the $4\times$ efficiency gain is a lower bound.

Robust verifier training resistant to over-optimization under aggressive search. The paper identifies verifier over-optimization as the primary bottleneck limiting test-time compute scaling (Sections 5.3, 8, and Appendix M), but does not propose solutions. This opens a direct research agenda: how do we train PRMs that remain calibrated when subjected to beam search or lookahead search at high budgets? A strong follow-up would: (a) train a PRM using adversarial data augmentation — include search-generated solutions (not just i.i.d. samples) in the training set, with labels derived from Monte Carlo rollouts on those search trajectories, (b) compare the over-optimization behavior of the adversarially trained PRM against the standard PRM on the same difficulty-dependent scaling curves as Figure 3 (right), measuring whether beam search accuracy on easy problems continues to degrade at high budgets, (c) test ensemble verification where multiple independently trained PRMs vote on step-level scores, and (d) test a KL-constrained search variant where beam search is penalized for selecting solutions whose token distribution diverges too far from the base model's unconditional distribution — analogous to the KL penalty used in RLHF to prevent reward hacking. The key metric is whether these interventions push the over-optimization threshold to higher budgets, allowing compute-optimal strategies to use more aggressive search on a wider range of difficulty levels.

Extending the compute-optimal framework to code generation with unit-test-based verifiers. All experiments use MATH with PRM-based verifiers trained via Monte Carlo rollouts. Code generation offers a complementary setting with important differences: (a) verifier quality is much higher — unit tests provide (nearly) ground-truth correctness signals rather than learned approximations, which should reduce over-optimization and change the difficulty-dependent scaling curves, (b) difficulty estimation is cheaper — the pass rate of a few sampled solutions on public test cases provides an immediate signal without requiring 2048 samples, and (c) revision behavior may differ — compiler errors and test failures provide structured feedback that the revision model can condition on, potentially making sequential revisions more effective than they are on math problems. A strong follow-up would replicate the paper's methodology on HumanEval or MBPP: characterize difficulty-dependent scaling of best-of-N, beam search, and revisions using unit-test pass rate as the verifier, construct compute-optimal allocation curves, and compare the efficiency gains against MATH. The key hypothesis to test is whether the higher-quality verifier signal in code generation pushes the compute-optimal policy toward more aggressive search strategies (since over-optimization is less severe) and whether the $4\times$ efficiency gain grows or shrinks relative to the MATH results.

Difficulty-conditioned data generation for self-improvement loops. The paper's compute-optimal framework provides a principled mechanism for allocating test-time compute when generating training data for self-improvement pipelines (e.g., STaR, ReST$^{\text{EM}}$). The current practice in these pipelines is to spend a uniform generation budget per training problem — but the paper shows that this is deeply suboptimal, because the return on additional compute varies dramatically with problem difficulty. A strong follow-up would: (a) implement a self-improvement loop where, in each iteration, the difficulty of each training problem is estimated (using the current model's pass@1 or PRM score distribution), (b) a compute-optimal strategy is selected per problem based on its estimated difficulty bin, (c) the model generates solutions using the allocated strategy (e.g., beam search for medium problems, sequential revisions for easy problems), (d) correct solutions are added to the training set and the model is fine-tuned, (e) the difficulty distribution is re-estimated for the next iteration (since the model's capability improves, problems may shift to easier bins). The key metrics are: total FLOPs consumed per iteration, accuracy improvement per FLOP, and whether the difficulty-conditioned allocation outperforms uniform allocation at matched total FLOPs. The paper's negative result with ReST$^{\text{EM}}$ (Appendix K, Figure 16) — where sequential revisions degraded performance — underscores that careful allocation matters even more in self-improvement contexts, where on-policy data generation can amplify spurious correlations.

Practical Applications and Downstream Use Cases

Data curation for fine-tuning video generation models on specific motion qualities. This is the application the paper directly demonstrates and the most immediately actionable. A studio or research lab with a pretrained video generation model (e.g., Wan2.1-T2V-1.3B or Wan2.2-TI2V-5B) and a fine-tuning corpus of 10k–100k videos wants to improve a specific motion quality — say, physically realistic bouncing, smooth camera pans, or fluid deformations. The one-time cost of computing projected motion-weighted gradients for the corpus (~2.3 hours on 64 A100 GPUs for 10k samples, per Table 6 and Appendix G.1) is amortized across all future queries. For each desired motion pattern, the practitioner provides 5–10 query videos (synthetic or curated), computes their projected gradients (~54 seconds each), scores the corpus (~46 ms dot-product sweep), selects the top 10% by majority vote, and fine-tunes. The paper's results (Table 1) show that this 10% subset outperforms both random selection and full-dataset fine-tuning on Dynamic Degree (47.6% vs. 41.3% vs. 42.0%), and the 74.1% human preference win rate (Table 2) confirms perceptual improvements. The key practical consideration is that the upfront gradient computation cost (~150 GPU-hours on a single A100) must be weighed against the ongoing benefit of improved generation quality across potentially many motion targets — a favorable tradeoff for organizations that fine-tune models repeatedly for different downstream tasks.

Diagnosing and debugging motion artifacts in deployed video generation systems. When a deployed video generation model produces artifacts — temporal flicker, objects that warp or drift, physically implausible collisions — the current debugging workflow is guesswork: inspect training data samples manually, tweak architecture, or add more data. Motive provides a systematic alternative. For a generated video exhibiting problematic dynamics, the practitioner computes its projected motion-weighted gradient and scores the training corpus. The highest-influence clips are the ones whose gradients most align with the artifact video's gradients — these are the clips most likely to have caused the model to learn the problematic dynamics. Inspection of these clips can reveal issues like mislabeled data, physically implausible source footage, or data that was fine for static appearance but harmful for motion. Conversely, low- or negative-influence clips suggest data that the model is not using for that specific motion pattern. The paper does not directly evaluate this diagnostic use case, but the cross-motion influence analysis (Figure 7, Appendix D.2) demonstrates that influence patterns are consistent across datasets and reflect physically meaningful motion similarities, suggesting that influence-based debugging would produce interpretable results. The practical workflow would be: (1) generate a video with problematic motion, (2) compute its Motive gradient and rank the training corpus, (3) inspect the top-100 most positively influential clips for common issues, and (4) remove, relabel, or augment those clips before retraining.

Selective data pruning for reducing fine-tuning dataset size without quality loss. For organizations maintaining large fine-tuning datasets (100k+ videos), storage, bandwidth, and training costs scale with dataset size. Motive offers a principled pruning strategy: rank all clips by their average influence score across a diverse set of motion queries (covering the desired motion distribution), and retain only the top-$X\%$. The paper's result that a randomly selected 10% subset underperforms full-dataset fine-tuning (Dynamic Degree 41.3% vs. 42.0%) while a Motive-selected 10% subset outperforms it (47.6%) demonstrates that influence-based pruning can simultaneously reduce dataset size and improve quality — a rare property. The paper does not test this at larger scales (10k is its working corpus size), but the cost structure in Appendix G.1 suggests the approach scales linearly with corpus size: gradient computation is $\mathcal{O}(|\mathcal{D}| \cdot B)$ and embarrassingly parallelizable. A practitioner with a 100k-video corpus would spend ~1,500 GPU-hours on a single A100 (or ~23 hours on 64 GPUs) for one-time gradient precomputation, then prune to 10k–20k videos that outperform the full corpus on targeted motion metrics. The practical constraint is whether the $D'=512$ projected gradient storage (~100 MB for 100k samples) is sufficient to preserve ranking quality at larger corpus sizes — the Johnson–Lindenstrauss guarantee depends on the number of points being compared, and the paper's ablation (Figure 4) only tested up to 10k samples. Extrapolating to larger corpora may require increasing $D'$ beyond 512.

Motion-aware data filtering for safety and governance in video generation. The paper discusses (Appendix G.3) using negative-influence filtering to "suppress undesirable or unsafe dynamics" and to "audit motion behaviors" in generated videos. This is a longer-term application that the paper does not evaluate, but the framework directly supports it. If a safety review identifies a specific undesirable motion pattern in generated outputs — e.g., violent collision dynamics, physically dangerous behavior, or motions that violate content policies — the practitioner computes the projected gradient for a query video exhibiting that pattern and identifies the highest-influence training clips. These clips can be: (a) removed from the training set to suppress the problematic motion, (b) audited to understand why they produce the undesirable behavior (are they labeled incorrectly? do they contain uncurated content?), or (c) downweighted during training via importance sampling. The same mechanism works in reverse: to promote desirable motion patterns (e.g., physically safe interactions, smooth professional camera movements), practitioners provide positive query videos and select high-influence clips for inclusion or upweighting. The practical challenge — which the paper does not address — is that motion safety is inherently more subjective and context-dependent than motion quality, requiring careful specification of query videos and influence thresholds. Misidentifying a "dangerous" motion could inadvertently suppress legitimate dynamic content. This use case therefore requires governance infrastructure (query review, audit trails, human oversight) beyond the technical attribution pipeline.

When to Prefer This Method

The paper positions Motive against several alternatives throughout the experiments. The decision rules are grounded in the paper's specific empirical comparisons:

• Prefer Motive over random data selection for fine-tuning when you have a specific motion quality target (e.g., improving bouncing, floating, or spinning dynamics) and a fine-tuning corpus of at least thousands of videos. Motive-selected 10% subsets achieve Dynamic Degree 47.6% vs. 41.3% for random selection (Table 1) and a 58.9% human preference win rate (Table 2), with the upfront gradient computation cost (~150 GPU-hours on 1 A100 for 10k samples, or ~2.3 hours on 64 GPUs per Table 6) amortized across all future motion targets. Random selection is appropriate only when no motion-specific improvement is needed (generic fine-tuning) or when the attribution computation cost cannot be amortized (one-off fine-tuning on a single target).

• Prefer Motive over full-dataset fine-tuning when the fine-tuning corpus contains substantial data that is irrelevant or harmful to the target motion quality. Motive with 10% of data achieves higher Dynamic Degree (47.6%) than full-dataset fine-tuning (42.0%) and higher subject consistency (96.3% vs. 95.9%), demonstrating that the excluded 90% of data contains negative-influence clips that dilute the training signal (Table 1). Full-dataset fine-tuning is appropriate when the corpus is already highly curated for the target motion (no negative-influence clips to exclude) or when preserving broad capability across all motion types is prioritized over maximizing any single motion quality.

• Prefer Motive over motion-magnitude-based selection when influence on a specific motion pattern matters more than simply selecting clips with high average optical flow. The motion magnitude baseline achieves Dynamic Degree 40.1% (barely above the 39.6% base model) while degrading Motion Smoothness (95.7% vs. 96.3% base) and Imaging Quality (63.2% vs. 65.7% base) — Table 1. Motive achieves 47.6% Dynamic Degree while maintaining all other metrics, and the motion distribution analysis (Figure 6, Appendix D.1) confirms that high-influence clips do not have higher average motion magnitude than low-influence clips (means of 3.85 vs. 3.69, only 4.3% difference). Motion-magnitude selection is appropriate only as a cheap preprocessing filter when gradient computation is infeasible, with the understanding that it will select noisy or low-quality clips that degrade other metrics.

• Prefer Motive over V-JEPA embedding-based selection when model-specific influence signals matter more than generic spatiotemporal similarity. V-JEPA selection achieves Dynamic Degree 41.6% — better than motion magnitude but far below Motive's 47.6% — while also degrading Motion Smoothness (95.6%) and Imaging Quality (62.7%) (Table 1). The gap confirms that self-supervised spatiotemporal representations, even from a state-of-the-art model, do not capture the model-specific gradient alignment that drives actual training influence. V-JEPA is appropriate when the model cannot be accessed for gradient computation (e.g., API-based models) or as a lightweight pre-filter to reduce the corpus size before applying Motive's more expensive gradient-based scoring.