acceptodds
Under review as a conference paper at ICLR 2027

FlashCHORD: Reusing and Reinforcing Distillation for Efficient 4D Scene Generation

Abstract

Recent advances in distilling 4D scene motion from video generation models have demonstrated promising results. However, lengthy optimization and motion artifacts limit their practical use. In this paper, we introduce FlashCHORD, a framework that generates more realistic motion with substantially shorter optimization times. At the core of our method is a strategy to retain and reuse supervision signals obtained from expensive video generation model evaluations. Our analysis further shows that optimizing deformation through matching rendered appearance often leads to motion artifacts, as the resulting motion is highly sensitive to the input appearance. We address this with semantics-aware coloring, which recolors scene regions to provide visual cues better suited to motion optimization. Together, these designs yield a framework that outperforms prior distillation-based methods in both runtime and motion quality. Extensive experiments demonstrate its effectiveness across diverse scenes and motion prompts. Video results are available at https://chordflash.github.io/chordflashpage/.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
4D Generation, 3D Computer Vision, Score Distillation Sampling

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_eDYaOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces FlashCHORD, a framework for generating scene-level 4D animations from static 3D scenes and text prompts. Building on CHORD, FlashCHORD uses several strategies to improve both efficiency and output quality. It caches and reuses supervision from a video model, refreshes the cache non-uniformly based on the learning-rate schedule, and actively selects camera views to improve motion coverage under a limited teacher-query budget. It also uses SAGA-like gradient memory to reduce the cost of replaying cached targets and semantics-aware coloring to distinguish semi-rigid regions and avoid incorrect correspondences in RGB-based reconstruction. The method reduces the runtime from CHORD’s 12 hours to 32 minutes while achieving better user preferences and automatic evaluation scores.

Critical strengths
  • Optimization-based 4D generation typically requires repeatedly querying large video generation models, and runtimes on the order of 12 hours severely limit its practical use. Through a set of well-motivated and comprehensive system designs, this work substantially reduces generation time, giving it strong practical value.

  • Pseudo-target caching, adaptive refresh scheduling, active camera selection, and gradient memory are all designed around a limited teacher-query budget, resulting in a coherent overall framework.

  • Assigning distinguishable colors to individual parts while preserving a compressed luminance field is a simple yet sensible design. It provides reliable correspondence cues while retaining local shape and shading information. Compared with relying entirely on the original RGB appearance, this strategy may be particularly effective for objects with weak or repetitive textures.

Critical weaknesses
  • The main experiment includes only six scenes, which is relatively small for a 4D generation task whose performance may vary substantially across humans, animals, rigid objects, multi-object interactions, and complex occlusions.

  • The equivalence between Eq. (5) and the RF-SDS gradient holds only at the scene state where the pseudo-target is generated. After the parameters are updated, the current latent zz changes, whereas the cached z⋆z^\star is still derived from the previous noisy latent and teacher-model input. The optimization therefore fits a stale reconstruction target rather than estimating the teacher gradient at the current scene state.

Questions for authors
  • Why does the objective ∫η(u)/ρ(u) du\int \eta(u)/\rho(u)\ du in Eq. (6) provide an appropriate measure of the error caused by stale targets?

  • The claimed 24×24\times speedup is inconsistent with the 22.5×22.5\times speedup calculated from the runtimes in the table. What are the exact runtimes?

1 comment

W1: Small main experiment.

We conducted baseline comparisons on nine additional scenes, with a user study involving 30 participants. As shown in Table 1, our method again achieves the best prompt alignment and motion realism, bringing the total number of scenes with baseline comparisons to 15. As running CHORD takes substantial time, we generated results for 20 further scenes with our method only, which are available on our project website.

Table 1: User study results compared with baselines

MethodPrompt alignmentMotion realism
FlashCHORD (Ours)55.93%56.67%
CHORD20.37%22.22%
AnimateAnyMesh0.37%0.74%
GPT-622.59%18.15%
UniWorld0.74%2.22%

W2: Validity of cached targets

While cached targets become stale as the optimization proceeds, they still provide valuable supervision signals beyond a single update. In our new matched-query user study across three scenes, the full method receives 93.33% preference over the variant that discards each target after one update. We therefore reuse these targets to exploit the acquired supervision, while accounting for the discrepancy introduced by their increasing staleness. This motivates Eq. (6), which models that discrepancy and guides the allocation of refreshes.

Q1: Explain why Eq. (6) appropriately measures the error caused by stale targets.

Measuring the error of a stale target directly would require additional teacher queries, which defeats the purpose of caching. Instead, we estimate the error from where it comes from: after a target is generated, the scene keeps evolving while the target stays fixed. The more the scene has changed since the target was generated, the staler the target becomes, so we use this change as a measure of the error, approximated by the learning rate accumulated since the target was generated.

Eq. (6) is the total of this proxy over the whole optimization, which depends on the learning rate schedule η(u)\eta(u) and the refresh schedule ρ(u)\rho(u). Between two refreshes, an interval of length about 1/ρ(u)1/\rho(u), the accumulated learning rate at time ss after the refresh is η(u)s\eta(u)s. Summing it over the interval and over the ρ(u)\rho(u) intervals per unit time gives

J[ρ]≈∫0Tρ(u)∫01/ρ(u)η(u) s ds du=12∫0Tη(u)ρ(u) du,J[\rho]\approx\int_0^T\rho(u)\int_0^{1/\rho(u)}\eta(u)\ s\ ds\ du=\frac{1}{2}\int_0^T\frac{\eta(u)}{\rho(u)}\ du,

which is the objective in Eq. (6).

To empirically assess this approximation, we analyze three scenes with two runs per scene, each using 22 checkpoints spanning the whole optimization process. At each checkpoint, we hold the current scene fixed and compare two sets of supervision:

  • Cached supervision: the 16 targets already retained in the cache.
  • Fresh supervision: targets regenerated from the current scene.

For each set, we compute fitting gradients with respect to the Gaussians’ deformed XYZ positions, since these gradients directly describe how the supervision encourages scene elements to move. The measured error is

E(k)=RMS⁡(g‾cached(k)−g‾fresh(k)).E(k)=\operatorname{RMS}\left(\overline{\mathbf g}_{\mathrm{cached}}(k)-\overline{\mathbf g}_{\mathrm{fresh}}(k)\right).

For the same cache, we sum the learning rates of updates completed since each target’s creation, which is our designed proxy, obtaining A(k)A(k). Across the six runs, E(k)E(k) and A(k)A(k) show Pearson correlations of 0.85–0.89, supporting accumulated learning rate as a practical proxy for the evolution of stale-target gradient discrepancy.

Q2: Provide the exact runtimes and reconcile the claimed 24× speedup with the 22.5× speedup calculated from the table.

We clarify that CHORD’s runtime is 12 h 33 min and ours is 31.5 min, which we rounded to 12 h and 32 min in the table. The reported 24× speedup was computed from the unrounded values (753 min / 31.5 min ≈ 24×).

Reviewer_GK9HOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper improves optimization-based 4D scene motion generation using reusable supervision from a video diffusion teacher. It rewrites the RF-SDS update as fitting a detached pseudo-target, maintains a FIFO target cache with a learning-rate-dependent refresh schedule, selects camera views to improve motion coverage, and uses gradient memory for efficient replay. A complementary semantics-aware coloring procedure makes different object parts more distinguishable during motion fitting. The paper reports 32-minute generation on an H200, compared with 12 hours for CHORD, and higher user preference on six multi-object scenes.

Critical strengths
  1. The method addresses two concrete bottlenecks in scene-level motion distillation: repeated expensive teacher evaluations and ambiguous appearance-based correspondences. The pseudo-target construction is well motivated, and combining reuse with motion-oriented appearance design is a useful systems contribution (Sections 3.2–3.3).
  2. The reported quality–runtime improvement is practically meaningful. On the six evaluated scenes, FlashCHORD obtains 48.69% of prompt-alignment votes and 54.74% of motion-realism votes, versus 33.99% and 31.37% for CHORD, while reducing reported optimization time substantially. The per-scene votes and runtime breakdown in the appendix help interpret these results.
Critical weaknesses
  1. The evidence does not sufficiently isolate the source of the efficiency improvement. Appendix A.6 changes the optimization timeline, learning rate, and frame count in addition to the cache-related mechanisms; Figures 7–8 provide qualitative rather than quantitative component comparisons. A matched-budget comparison against CHORD and a simple reuse baseline, with quality plotted against teacher queries and wall-clock time, would make the central efficiency claim much more convincing. The exact-gradient equivalence at target construction alone does not establish the quality of subsequent stale-target updates.
  2. The quantitative validation is narrow relative to the robustness claim. The user study covers six scenes, and the critical component ablations are illustrated on individual examples. The 102 participants provide useful preference evidence but do not address variability across scenes or optimization seeds. In addition, the VLM-based part-decomposition procedure is not specified sufficiently to assess reproducibility and the complete preprocessing cost (Appendix A.5).
Questions for authors
  1. Can you provide quantitative, matched-budget results separating target reuse, refresh scheduling, camera selection, coloring, and the compressed optimization/frame schedule? Existing runs across the evaluated scenes would already help establish which changes account for the quality–runtime gain.
  2. Does the reported 32-minute runtime include part decomposition, all VLM calls or corrections, color preparation, initialization, and transfer back to the input meshes? Please specify the VLM and whether any manual corrections are used, and give the unrounded times underlying the 24× claim.
  3. How sensitive are quality and variance to cache capacity, replay batch size, and teacher-query budget? In particular, what failures occur when cached supervision becomes stale or when the initial appearance/part decomposition is unreliable?
4 comments

We thank the reviewer for their thoughtful comments and suggestions and address their concerns below.

W1: Matched-budget comparison against CHORD and a simple reuse baseline.

As suggested, we conduct controlled quantitative studies under matched teacher-query budgets, comparing three methods. The first is CHORD equipped with our semantics-aware coloring and training schedule, so that, for a fair comparison it differs from our method only in the efficiency mechanisms. The second, a target reuse baseline, adds our proposed target caching and reuse to this CHORD, with uniformly spaced refreshes and randomly sampled cameras. The third is our full method, which further adds our refresh schedule and active camera selection. For each budget, we conduct a user study with 30 participants on 3 scenes.

Compared with CHORD, our method is strongly preferred at budgets of 550 and 2200 (97.78% and 92.22%, Table 1). By reusing each target across several updates, it extracts substantially more supervision from every query. CHORD reaches comparable quality only at a budget of 8800, where queries are abundant enough for CHORD’s one-update-per-query supervision to catch up, and the two methods reach comparable quality.

Table 1: User study results compared with CHORD

Budget55022008800
Our runtime40.1 min113.2 min417.6 min
Baseline runtime39.5 min116.9 min445.8 min
Win rate97.78%92.22%53.33%

Compared with the target reuse baseline, our method is preferred at all budgets, receiving 57.78%, 66.67%, and 54.44% of preferences at budgets of 125, 360, and 500 (Table 2). The advantage is largest at our default budget of 360, where the budget is limited but still sufficient to keep supervision useful, so careful allocation of refreshes matters most.

Table 2: User study results compared with a target reuse baseline

Budget125360500
Our runtime20.6 min31.5 min38.0 min
Baseline runtime20.4 min31.4 min38.0 min
Win rate57.78%66.67%54.44%

In conclusion, target reuse introduces substantial performance gain. At the same number of teacher queries, it lets our method extract far more supervision than CHORD. On top of that, our refresh scheduling and active camera selection method allocate the limited queries to the right iterations and views, further improving quality at low budgets.

W2: Quantitative validation to more scenes and assessing variability across scenes and optimization seeds.

We extended our baseline comparison experiment to 9 additional scenes and conducted a user study with 30 participants. Results are shown in Table 3. Our method achieves the best performance in both motion realism and prompt alignment.

Table 3: User preferences on nine additional scenes

MethodPrompt alignmentMotion realism
FlashCHORD (Ours)55.93%56.67%
CHORD20.37%22.22%
AnimateAnyMesh0.37%0.74%
GPT-622.59%18.15%
UniWorld0.74%2.22%

In terms of scene variability, we examine how our method performs in each of the 15 scenes compared. It is the most preferred method in 12 of the 15 scenes for both prompt alignment and motion realism. Treating each scene as an independent observation, its advantage over the best competing method in each scene is also statistically significant, with p = 0.02 for prompt alignment and p = 0.01 for motion realism under a Wilcoxon signed-rank test over scenes. This confirms that the improvement is not driven by a few scenes.

In terms of seed variability, we ran our method with 3 seeds on 6 scenes and asked 33 participants to choose the best of the three seeds for each scene. On average, the most preferred seed received 50.51% and the least preferred 21.21%, indicating moderate differences between seeds. To assess whether the performance advantage persists across optimization seeds, we compared each seed on every scene with CHORD using 30 participants: every seed on every scene outperformed CHORD, with an overall win rate of 78.89%.

W3: Specify the VLM-based part-decomposition procedure.

The VLM agent is GPT-6 Astra, run through the Codex CLI at medium reasoning effort with fast mode on. For efficiency, we first split the mesh into 320 surface patches and let the agent work on patches rather than the raw mesh. To make the patches, we spread 320 seed points evenly over the surface and assign each vertex to its nearest seed, measured along the surface. The agent then only has to decide how the patches group into parts. It sees textured multi-view renders of the object and of the numbered patches, has access to geometric statistics of the patches, and is asked to group them into semi-rigid parts: regions that move as one coherent unit. After the initial grouping, the agent reviews its result and refines it where needed. No manual correction is applied at any stage of this processing for any of the scenes.

Q2: Clarify preprocessing cost and the unrounded runtimes.

Our reported 32 minutes include preprocessing, which takes 99 s per scene on average; the VLM accounts for about 68 s of this. The unrounded runtimes are 12 h 33 min for CHORD and 31.5 min for ours, rounded to 12 h and 32 min, respectively. The 24× speedup was computed from the unrounded values (753 min / 31.5 min ≈ 24×).

Q3: Quantitative, matched-budget results separating each component?

We remove one component at a time while keeping the number of teacher queries fixed, and compare each ablation with the full method in a user study spanning 3 scenes and on 30 participants. Results are shown in Table. 4. The full method is preferred over every ablation that removes target reuse, refresh scheduling, camera selection, or coloring, confirming that each of these components contributes to motion quality under a limited teacher query budget. The compressed optimization and frame schedule are efficiency components: removing them yields comparable quality (53.33%).

Table 4: User study results after removing one component

No target reuseNo refresh scheduleNo camera selectionNo colouringNo compression + frame schedule
Runtime33.5 min31.6 min30.7 min30.8 min64.2 min
Full vs. ablation93.33%67.78%63.33%93.33%53.33%

Q4: How sensitive are quality and variance to cache capacity, replay batch size, and teacher-query budget?

We evaluate each setting on 3 scenes with two user studies. For quality, 30 participants compare our default configuration with each variant (Table 5). For variance, we run each setting with 3 seeds and ask 28 participants to choose the best of the three seeds for each scene, then report the standard deviation of the seeds’ preference shares, averaged over scenes (Table 6).

SettingCache 8Cache 32Replay K=1Replay K=16Budget 125Budget 500
Win rate62.22%60.00%88.89%47.78%70.00%52.22%

Quality is most sensitive to the low end of the replay batch size and the teacher-query budget. Replaying a single target per step causes the largest drop, as each update relies on one view and the optimization becomes noisy. Reducing the budget to 125 causes the next largest drop, as targets become stale between sparse refreshes. Changing the cache capacity in either direction has a moderate effect: a smaller cache discards targets before they are fully used, while a larger one keeps stale targets for too long. Increasing the replay batch size to 16 or the budget to 500 leaves quality largely unchanged.

Table 6: Seed standard deviation under different settings.

SettingDefaultCache 8Cache 32Replay K=1Replay K=16Budget 125Budget 500
Seed SD (pp)13.814.913.716.813.915.913.1

Seed-to-seed variation is modest and similar across cache capacities and budgets, and our default is among the most stable settings. Reducing the replay batch to a single target gives the largest variation, consistent with a noisier supervision signal when fewer cached targets are averaged per update.

Q5: What failures occur when cached supervision becomes stale or when the initial appearance/part decomposition is unreliable?

Stale supervision. When cached targets are refreshed too rarely, the global motion is still observable, but local deformations become noisy. The global movement changes slowly during optimization, so even stale targets agree on it. Local details depend more closely on the current state of the scene, so stale targets give conflicting local corrections.

Unreliable part decomposition. We test a severe setting in which each object is assigned only a single part. In this case, the coloring cannot provide reliable visual cues for optimization, which leads to distortions similar to those shown in the paper when semantics-aware coloring is removed. Both cases stem from the same issue: visual cues that are not suited to motion optimization. This further confirms that semantics-aware coloring is key to accurate motion. In practice, modern VLMs provide reliable part decompositions thanks to their strong pretrained capabilities.

Thank you for the detailed response and additional experiments. The matched-budget comparisons address my main concern by showing that cached targets provide useful supervision even when the teacher-query budget is limited. The additional scene comparisons address my concern about the scope of the evaluation, and the runtime breakdown clarifies what is included in the reported speedup. The component ablations still cover only three scenes, but the new evidence addresses most of my concerns. I am raising my rating from 2 (Weak rejection) to 3 (Weak acceptance).

Reviewer_XMD9OpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The authors introduced a framework accelerating 4D scene motion generation by reusing supervision signals from video diffusion models. The proposed method maintains a fixed-capacity cache to store and replay pseudo-targets. It also applies semantics-aware colouring to the input meshes to prevent motion artifacts caused by appearance ambiguities during the optimisation process. Experimental results demonstrate that the proposed method drastically reduces generation time and improves motion realism compared to existing baseline methods.

Critical strengths
  • The proposed method reduces expensive teacher evaluations by caching and reusing their supervision across multiple scene updates.
  • The proposed method optimises motion using surrogate appearances, obtained by recolouring the original meshes with semantics-aware textures.
Critical weaknesses
  • The authors introduced reusable pseudo-target distillation and semantics-aware colouring to improve the efficiency and stability of the existing CHORD framework. While experiments show meaningful performance gains, I’m not still convinced if this level of incremental contributions are sufficient for ICLR.
  • The main claim regarding motion quality and text alignment relies heavily on a user study with 102 participants, but it is not accompanied by any statistical validation for subjective evaluation.
Questions for authors
  • Highlight the main differences and their values against the baseline methods
  • Statistical validation of the user study is required.
3 comments

We thank the reviewer for their thoughtful comments and suggestions and address their concerns below.

Q1: Highlight the main differences against the baselines

Existing approaches to 4D scene motion generation fall into four paradigms, and we compare against a representative of each:

  • Feed-forward generation (AnimateAnyMesh) learns directly from 4D data, which is scarce at the scene level. As a result, it rarely follows scene-level prompts and tends to leave objects static.
  • Video-to-4D reconstruction (UniWorld-View) first generates videos and then lifts them to 4D. Errors from depth estimation, multi-view generation and reconstruction accumulate into geometric artifacts.
  • LLM-authored motion (GPT-6-Astra) follows the prompt but lacks a motion prior, so the resulting motion is unnatural.
  • Distillation from video models (CHORD) leverages the rich motion priors of video generation models while keeping the 3D geometry consistent. This makes it currently the strongest paradigm, and CHORD is by far the best baseline in our experiments.

Distillation, despite its prevalence among baselines, has a fundamental issue: its supervision is both expensive and unreliable for motion generation, limiting its practical use. CHORD takes over 12 hours to generate a single clip and still produces motion artifacts. Our contributions address these two fundamental limitations of distillation. Supervision reuse avoids repeated expensive teacher queries, and semantics-aware coloring makes the supervision informative for deformation, improving motion quality at the same time. This turns distillation from a proof of concept into a practical tool, for example, making long-horizon generation of many consecutive clips feasible, as shown in our experiments.

W1: Improve the efficiency and stability of the existing CHORD framework. I’m not convinced that this level of incremental contribution is sufficient for ICLR.

Our method addresses a fundamental limitation of distillation-based methods: their low efficiency, which limits their practical use. On CHORD, it yields a 24× speed-up, making the approach viable in real applications. The method is not specific to CHORD. Applying only our target caching and refresh scheduling to DreamGaussian, a distillation-based 3D generation pipeline, yields a 1.60× speed-up at similar quality (CLIP similarity 0.660 vs. 0.662). Applying our full method to TC4D, a distillation-based 4D generation pipeline, yields a 2.90× speed-up and improves the CLIP score from 27.15 to 27.39. In short, our approach applies to distillation-based generation in general, and its efficiency gains allow such methods to become applicable.

W2, Q2: Statistical validation of the user study is required

We analyzed the 102 participants’ individual responses, treating each participant’s six votes as dependent: confidence intervals are 95% bootstrap intervals obtained by resampling participants.

Vote share per method (95% CI)

MethodText alignmentMotion realism
AnimateAnyMesh1.5% [0.5, 2.8]1.3% [0.5, 2.3]
UniWorld-View0.8% [0.2, 1.6]0.2% [0.0, 0.5]
GPT-6-Astra15.0% [12.1, 18.0]12.4% [9.8, 15.0]
CHORD34.0% [30.2, 37.8]31.4% [27.3, 35.5]
Ours48.7% [44.6, 52.8]54.7% [50.2, 59.2]

Ours vs. each baseline (participant-level Wilcoxon signed-rank test, Holm-corrected; r = rank-biserial effect size)

BaselineText alignmentMotion realism
CHORD56 / 27, p = 1.7e-4, r = 0.4762 / 26, p = 1.2e-6, r = 0.59
GPT-6-Astra84 / 12, p = 3.5e-13, r = 0.8686 / 5, p = 2.2e-15, r = 0.96
AnimateAnyMesh97 / 1, p = 2.8e-17, r = 0.9999 / 1, p = 9.4e-18, r = 1.00
UniWorld-View97 / 2, p = 1.8e-17, r = 1.00101 / 1, p = 6.0e-18, r = 1.00

Counts are participants who chose our method more often / less often than the baseline (the rest are ties). Our method is significantly preferred over every baseline on both criteria, with medium-to-large effects even against the strongest baseline, CHORD.

Overall, the authors addressed my concerns well. However, despite having a two-week discussion period, uploading all responses at once on the very last day leaves no room for further discussion. This feels intentional and is disappointing.

  • Q1: The core differences against the baselines are clearly highlighted. This concern is addressed.
  • W1: The authors demonstrated that the method is not limited to CHORD by showing its generalisability on DreamGaussian. However, providing only raw numbers is disappointing. More specific experimental details should be included.
  • W2, Q2: The statistical validation is addressed. However, evaluating on only six scenes remains a limitation. Looking at Table 2 alone, roughly half of the scenes show similar results between CHORD and FlashCHORD, while the overall average is biased by a strong advantage in a few specific scenes. Future experiments with a larger sample of scenes are needed.

Dear Reviewer XMD9,

Thank you for reading our response and for the follow-up. We sincerely apologize for the timing of our response. We waited until all new results were in, and the 11 new experiments and 12 user studies took longer than we expected, alongside other deadlines. Below we answer your remaining questions.

W1: Specific experimental details

DreamGaussian: We applied our target reuse and refresh schedule to the original DreamGaussian pipeline, keeping all of its hyperparameters. Instead of querying the teacher at every update, 500 queries in total, we query it only at 125 refresh steps placed by our refresh schedule, and store each target with its camera in a cache of size 8. At all other updates, we re-render the cached cameras with the current Gaussians and fit the renderings to their stored targets. For evaluation, we use 8 input images, score the results with DreamGaussian’s CLIP similarity, and report the average.

TC4D: We applied the same target reuse and refresh schedule to TC4D, keeping all of its hyperparameters, and further applied our semantics-aware coloring to the renderings used to build each new target. We set the teacher query budget to 1000 instead of the original 5000, with a cache size of 16. For evaluation, we tested on 4 scenes, rendered them with the original texture, scored the results with CLIP text–frame similarity, and reported the average.

W2, Q2: Further baseline analysis

As requested by other reviewers, we have extended the baseline comparison with 9 new scenes and a user study of 30 participants, bringing the total number of scenes compared to 15. The video results are available on our project website.

Table 1 reports the vote share of each method with 95% confidence intervals. Our method receives the majority of votes for both criteria, more than twice the share of the strongest baseline.

Table 1: Vote share on the 9 new scenes.

MethodPrompt alignmentMotion realism
AnimateAnyMesh0.4% [0.0, 1.1]0.7% [0.0, 1.9]
UniWorld-View0.7% [0.0, 1.9]2.2% [0.7, 4.4]
GPT-6-Astra22.6% [16.3, 29.3]18.1% [13.3, 23.3]
CHORD20.4% [15.2, 25.6]22.2% [17.8, 27.0]
Ours55.9% [48.9, 63.0]56.7% [50.0, 63.3]

Following the analysis in our previous response, Table 2 compares our method with each baseline at the participant level using Wilcoxon signed-rank tests with Holm correction. Our method is significantly preferred over every baseline on both criteria, with large effect sizes, including against CHORD.

Table 2: Participant-level comparison on the 9 new scenes.

BaselineText alignmentMotion realism
CHORD26 / 3, p = 4.7e-5, r = 0.9027 / 2, p = 1.8e-5, r = 0.91
GPT-6-Astra24 / 4, p = 1.9e-4, r = 0.8026 / 4, p = 1.8e-5, r = 0.92
AnimateAnyMesh30 / 0, p = 5.9e-6, r = 1.0030 / 0, p = 6.4e-6, r = 1.00
UniWorld-View30 / 0, p = 5.9e-6, r = 1.0030 / 0, p = 6.4e-6, r = 1.00

Consistency across all 15 scenes. To examine whether the overall advantage is driven by a few specific scenes, we analyze the per-scene results against CHORD over all 15 compared scenes, treating each scene as one observation (Table 4).

Table 4: Per-scene comparison with CHORD over 15 scenes. The lead is our method's vote share minus CHORD's vote share in each scene.

Prompt alignmentMotion realism
Scenes where ours receives more votes than CHORD12 / 1513 / 15
Scenes where ours leads CHORD by at least 10 points9 / 1510 / 15
Median per-scene lead over CHORD+33.3 points+29.4 points
Mean per-scene lead over CHORD+27.2 points+30.0 points
Scene-level p, all 15 scenes7.6e-39.0e-4
Scene-level p, excluding the 3 scenes with the largest lead4.1e-26.8e-3

Our method leads CHORD in the large majority of scenes, in most of them by a clear margin. In a typical scene, its vote share exceeds CHORD’s by about 30 points, with a median lead of 33.3 points for prompt alignment and 29.4 for motion realism. Moreover, the advantage remains statistically significant under a scene-level Wilcoxon signed-rank test even after excluding the three scenes with the largest lead. These results show that the improvement holds consistently across scenes.

Thank you again! Please let us know if you have any other questions.

Best, Authors

Comments on the paper

1 comment

We thank each of the reviewers for their constructive suggestions and will use them to improve the quality of our paper accordingly. All reviewers recognize that our method substantially reduces generation time (XMD9, GK9H, eDYa), which is “practically meaningful” (GK9H) and gives it “strong practical value” (eDYa). They also find the method “well motivated” (GK9H, eDYa) and “coherent” (eDYa), and semantics-aware coloring “simple yet sensible” (eDYa). We respond to each reviewer below and will update the paper accordingly.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.