{"id":"4994e59c-5a73-47a0-90fa-ae7d8f40a301","arxiv_id":"2501.03875","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":5.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":3,"one_line_summary":"A zero-shot dynamic scene stylization method that applies AdaIN directly to learned per-Gaussian feature vectors, using a running average of feature statistics for spatio-temporal consistency.","lead":"ZDySS trains a dynamic 3D Gaussian Splatting scene to carry per-Gaussian style features, then applies AdaIN-style style transfer at inference to arbitrary unseen style images without per-style retraining. The result is a zero-shot dynamic scene stylization method that aims to keep stylized output consistent across viewpoints and time.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The claimed consistency hinges on a single global running-average normalization of rendered features; no evidence shows per-view/per-frame statistics stay close to that average, so the central zero-shot consistency claim is unproven.","rationale":"The reader's weakest_assumption points to the global running-average normalization and the view/time invariance of the learned features. My concern is the operational version of that: the running-average statistics must match the per-view/per-frame statistics of the rendered feature map for the AdaIN-style affine to be well-posed. This is the single most load-bearing condition for the central claim because consistency and stylization quality both depend on it, and the paper provides no direct evidence that the condition holds. The provided test would settle it by measuring the statistical mismatch and, more importantly, by adding style-fidelity and content-preservation metrics, which are absent from the current evaluation. I keep the reader's CONDITIONAL verdict rather than moving to ACCEPT or REJECT because the method may still work in practice, but the current evidence is insufficient to confirm the central claim.","tokens_in":13114,"tokens_out":9032,"duration_ms":94686,"concrete_test":"On the Plenoptic Video scenes, after training, render F_r for all held-out views and timestamps and compute per-channel mean and std per frame; plot the distribution of deviations from μ_avg and σ_ma. Then re-run the Table 2/3 evaluation adding a style-loss term (e.g., Gram-matrix distance between stylized view and style image) and a content-preservation metric (e.g., LPIPS between stylized and unstylized views). If a substantial fraction of frames deviates more than 20% in mean or std from the running average, or if the running-average version is not significantly better than the naive per-frame AdaIN on style fidelity, the fixed-normalization assumption fails and the consistency claim is not established.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The load-bearing step is Section 4.2: instead of normalizing each rendered feature map by its own channel mean and std (Eq. 5), ZDySS normalizes every Gaussian's feature vector by a training-time running average (μ_avg, σ_ma) and only then applies the style affine. Because of the linearity assumed between Eq. (3) and Eq. (5), this is equivalent to normalizing every rendered feature map with fixed constants. For the result to be a faithful AdaIN stylization, the per-view and per-timestamp statistics of F_r must be sufficiently close to μ_avg and σ_ma; otherwise the style's mean and variance are applied to content that is not zero-mean/unit-variance, producing under- or over-stylization and view-dependent artifacts. The paper does not check this: Table 3 reports only a consistency metric that the authors themselves note favors blurry/smooth outputs, and the differences between the naive per-frame normalization and the running-average version are tiny. No style-fidelity or content-preservation metric is reported, and the pretrained AdaIN decoder (Section 5.1) is sensitive to input feature statistics, so a mismatch could directly break the claimed consistent stylization across views and timestamps.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes ZDySS, a zero-shot stylization framework for dynamic scenes built on 4D Gaussian Splatting. Each Gaussian is augmented with a 512-dimensional learned feature vector supervised by VGG features, and at inference the method applies Adaptive Instance Normalization (AdaIN) directly to these per-Gaussian feature vectors, using channel-wise mean and standard deviation from a running average of rendered feature statistics computed during training. The stylized features are then rendered and decoded by the pretrained AdaIN decoder. The claimed contributions are zero-shot operation (no per-style optimization), spatio-temporal consistency across views and timestamps, and the absence of a learned style-transfer module. Experiments are conducted on the Plenoptic Video Dataset with four style images, comparing against S-DyRF and two synthetic baselines, with consistency metrics (warped RMSE and LPIPS) and ablations on style interpolation, pretraining, and the running-average normalization.","tokens_in":13347,"tokens_out":8960,"duration_ms":80852,"significance":"If the central claims hold, ZDySS would be a practically useful method: after a single training pass on a dynamic scene, arbitrary unseen styles could be applied at inference without per-style optimization, with multi-view and temporal consistency. The idea of applying AdaIN to per-Gaussian features is a natural extension of static-scene StyleGaussian to dynamic scenes, and the running-average normalization is simple and computationally efficient. The paper is clearly written and the method is conceptually straightforward. However, the current validation is insufficient to establish the claimed consistency and superiority: the quantitative evaluation relies solely on consistency metrics that the authors concede favor blurry outputs, the ablation for the key running-average component shows only marginal differences, and a technical claim about the linearity equivalence between per-feature and per-map AdaIN is not exact. The novelty over concurrent work (4DStyleGaussian) appears limited to the running-average normalization, so the evidence for that component is especially important.","major_comments":[{"comment":"The paper claims that applying AdaIN to per-Gaussian features is equivalent to applying it to the rendered feature map 'due to the linearity of the affine operation.' This is not exact. The rendered feature map is F_r = sum_i f_i alpha_i T_i, and applying the affine y = a f_i + b to each Gaussian before rendering yields a F_r + b sum_i alpha_i T_i, whereas applying the same affine to the rendered map yields a F_r + b. The factor sum_i alpha_i T_i is the accumulated opacity, which is generally less than 1 in semi-transparent and background regions, so the discrepancy b(1 - sum_i alpha_i T_i) is nonzero. This is load-bearing because the entire inference procedure and the claimed consistency advantage rest on this equivalence. Please provide a corrected derivation (e.g., accounting for opacity) or empirical evidence that the discrepancy is negligible for the tested scenes and styles.","section":"Section 4.2, Eq. (3) and Eq. (5)"},{"comment":"The quantitative results do not support the abstract's claim of 'superior performance and coherence.' Only consistency metrics (warped RMSE and LPIPS) are reported, and the authors themselves note that these metrics favor blurry or smoothed outputs. On several rows, such as long-range view consistency and long-range time consistency, S-DyRF achieves lower (better) RMSE and LPIPS than ZDySS. No metrics are reported for style fidelity, content preservation, or perceptual quality, and the evaluation uses only four style images from a single dataset. To support the central claim, the authors should add appropriate evaluation (e.g., style loss, content loss, FID/KID, user study) and expand the experiments to more styles and at least one additional dynamic scene dataset.","section":"Section 5.4, Table 2"},{"comment":"The ablation for the running-average normalization shows only marginal differences from the naive per-frame normalization (e.g., short-range view consistency RMSE 4.82 vs 4.87 and LPIPS 0.52 vs 0.54). Given that the consistency metric is known to favor smooth outputs, these small differences are not persuasive evidence that the running average improves spatio-temporal consistency. The authors should provide statistical significance over multiple runs, a more sensitive metric, or a direct analysis of the distribution of rendered feature statistics across views and timestamps to demonstrate that a single global normalization is valid for faithful AdaIN.","section":"Section 6.3, Table 3"},{"comment":"The contribution bullet 'we do not need a pre-trained style transfer module' is overstated. ZDySS relies on a pretrained VGG encoder and, crucially, the pretrained AdaIN decoder from [18] to convert stylized features into an RGB image. The decoder is a component of a style transfer system. What the method avoids is training a style-specific transformation MLP or performing per-style optimization. Please rephrase the claim to accurately reflect the use of pretrained components.","section":"Contributions and Table 1"}],"minor_comments":[{"comment":"Equation (1) is not a valid Gaussian function: it is written as G(X) = exp(-1/2 mu^T Sigma^{-1} mu), which is independent of X. The correct expression should be G(X) = exp(-1/2 (X-mu)^T Sigma^{-1} (X-mu)).","section":"Section 3.1, Eq. (1)"},{"comment":"The notation in the consistency metric formulas is not fully defined. Please define the warping function W, the masking function M_v, and the rendered view O_v, and clarify the meaning of 'masking' in this context.","section":"Section 5.4, Eqs. (8) and (9)"},{"comment":"The caption states 'The metrics are scaled by 10^3 for readability,' but it is unclear whether the table entries are the raw values multiplied by 10^3 or the raw values divided by 10^3. Please clarify.","section":"Table 2 caption"},{"comment":"The paper states that metrics were computed on 'a randomly chosen set of four style images.' For reproducibility, please specify which four style images were used.","section":"Section 5.4"},{"comment":"There are several typos, including 'feed-feed forward' (should be 'feed-forward'), 'deadling' (should be 'dealing'), and 'consistencies' (likely 'inconsistencies').","section":"Section 2.2 and Section 5.4"},{"comment":"The pretraining ablation is presented only qualitatively. Consider adding a quantitative comparison (e.g., rendered image metrics or stylization quality scores) to support the claim that pretraining retains finer details.","section":"Figure 5 and Section 6.2"},{"comment":"The meaning of the '#Styles' column is ambiguous: for S-DyRF it lists '1', but S-DyRF is optimized per style, so it can handle different styles after retraining; please clarify what the column represents.","section":"Table 1"}],"recommendation":"major_revision","confidential_remarks":"The paper presents a simple and elegant idea, but the technical justification for the key running-average normalization is flawed (the linearity claim is not exact) and the evaluation is currently too weak to support the central claims of consistency and superiority. I believe these issues are fixable within the scope of a revision: the authors can correct the derivation, add opacity-aware normalization, and substantially strengthen the quantitative and perceptual evaluation. I would not recommend acceptance without addressing these points."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Quick take: the running-average normalization idea is clean and the writing is clear, but the paper's evidence is a lot thinner than its claims. The central consistency claim rests on an assumption that per-view and per-time feature statistics stay close to the training-time average, and the paper never verifies that.\n\nWhat's genuinely new: applying AdaIN to per-Gaussian feature vectors in a dynamic Gaussian splatting pipeline, with a global running average replacing per-frame normalization. This is a sensible way to attack the flicker problem that plagues naive AdaIN on rendered feature maps, and it sidesteps training a style module. The qualitative results look reasonable, and the paper is honest about the consistency metric favoring blurry outputs. The ablations on pretraining and style interpolation are useful.\n\nThe soft spot is the missing validation of the key assumption. The stress-test note is on point: the method normalizes every Gaussian with fixed statistics (running average) and then applies the style affine. If the rendered feature map statistics drift from that average, the stylization will be inconsistent or washed out. Table 3 is the only evidence, and the differences over the naive per-frame version are tiny (RMSE 4.82 vs 4.87, LPIPS 0.52 vs 0.54). No style fidelity or content preservation metric is reported. The missing head-to-head with 4DStyleGaussian, a concurrent method the authors themselves cite, is a real gap. Implementation details are also incomplete: the running-average momentum, the exact computation of statistics over rendered feature maps, and the VGG feature layer are not specified, which hurts reproducibility.\n\nFor a reader working on 3D stylization, this is a useful idea and a legitimate building block, but it is not a demonstrated win. I would send it to peer review at a specialized venue, but expect the authors to add a distribution analysis of the feature statistics, a proper style-fidelity metric, and a direct comparison to 4DStyleGaussian. Without those, the main claim remains unproven.","headline":"Clean idea with thin evidence: the running-average normalization for zero-shot dynamic stylization is plausible, but the paper never validates its core assumption about stable feature statistics.","tokens_in":13903,"tokens_out":4509,"would_cite":false,"duration_ms":44305,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"The paper claims that a dynamic 3D scene, once trained as feature-augmented Gaussian splatting, can adopt arbitrary unseen style images at inference with no per-style optimization and no trained stylization network.","keywords":["zero-shot stylization","dynamic scenes","Gaussian splatting","adaptive instance normalization","feature fields","4D Gaussian splatting","style transfer","spatio-temporal consistency"],"falsifier":"Render held-out views and timestamps from a trained scene and compute the actual mean and standard deviation of each rendered feature map; if those per-image statistics deviate sharply from the training-time running average in a way that produces visible flicker, color shifts, or lost style detail over longer time gaps, the core claim fails. A concrete test would use a scene with a large moving object or changing illumination and compare ZDySS with per-image AdaIN normalization on long-range temporal consistency.","tokens_in":12879,"feed_emoji":"🎨","tokens_out":7218,"duration_ms":57569,"temperature":0.7,"pith_summary":"The paper introduces ZDySS, a zero-shot stylization framework for dynamic scenes built on Gaussian splatting. Once a dynamic scene is trained, any previously unseen style image can be applied at inference, which would make stylizing moving content in games, film, and AR/VR a one-time cost instead of a per-style optimization. The central move is to attach a learned feature vector to each 3D Gaussian, then apply AdaIN (adaptive instance normalization) directly to those per-Gaussian vectors using a training-time running average of rendered feature statistics. If correct, the method removes the two main bottlenecks of earlier dynamic-scene stylization: per-style retraining and dependence on a large dataset to train a style-transformation module. The authors report stylized novel views across multiple styles on the Plenoptic Video dataset, with quantitative consistency comparisons against S-DyRF, StyleDyRF, and two synthetic Gaussian baselines.","feed_headline":"Restyle a moving scene with any new image, zero retraining","feed_subtitle":"Per-Gaussian features and running-average statistics let one trained scene adopt any style at test time.","key_machinery":"The machinery is feature-augmented dynamic Gaussians combined with running-average AdaIN. Each Gaussian deformed by 4DGS-style hexplanes carries a learnable 512-dimensional feature vector, rendered by the Feature 3DGS renderer into a feature map that is supervised by VGG features. During training a moving average of the rendered feature map's mean and standard deviation is recorded; at inference, the per-Gaussian features are normalized by these global statistics, scaled and shifted by the style image's statistics via AdaIN, then rendered and decoded by the AdaIN decoder. The linearity of the affine map in both the normalization and the rendering is what lets the style transformation be applied per-Gaussian, avoiding per-view normalization that would break consistency.","core_discovery":"The central claim is that zero-shot stylization of a dynamic scene is achieved by aligning each 3D Gaussian with a 512-dimensional feature vector supervised by VGG features, then applying the AdaIN affine transformation directly to those per-Gaussian vectors at inference using the style image's feature statistics. Because both AdaIN's affine operation and the volume rendering are linear, this per-Gaussian operation equals normalizing the rendered feature map, but the statistics used are a training-time running average of the rendered features rather than the statistics of any single view or frame. That shared normalization is what preserves spatio-temporal consistency, and the method needs neither style-specific retraining nor a pretrained style-transfer module. The paper validates this on real-world dynamic scenes from the Plenoptic Video dataset, showing stylized outputs at novel views and timestamps across diverse, unseen styles.","pith_inferences":["The running-average normalization assumes the per-Gaussian feature statistics are stationary across views and time; scenes with drastic appearance changes, such as sudden lighting shifts or moving occluders, might break that stationarity, and a per-region or per-time-statistics variant would be a natural extension.","The same per-Gaussian affine-editing trick is not limited to AdaIN: other linear feature transforms, such as whitening-and-coloring or linear style projections, could be applied directly to the Gaussians provided global statistics are estimated once.","Since style is baked into per-Gaussian features, one could precompute stylized feature vectors for several styles and switch between them without re-rendering, which would make multi-style dynamic scene delivery cheap at runtime.","The style space is coupled to the VGG encoder; exchanging that encoder for a foundation model could broaden the range of transferable styles, but that is beyond what the paper tests."],"forward_implications":["Any style image seen for the first time can be applied to the trained scene instantly, enabling interactive style editing of dynamic content in games, film, and AR/VR.","Because no style-specific optimization is required, the marginal cost of adding a new style is essentially zero after the one-time scene training.","The shared running-average statistics keep AdaIN-based transfer consistent across the spatio-temporal domain without optical-flow or temporal regularization.","Style interpolation at inference between two style latent vectors works directly, indicating the feature space supports continuous style control.","The method avoids the blurriness and Gaussian-spiking artifacts the paper attributes to training a 4DGS scene directly on stylized images."],"supporting_citations":[{"why":"Introduces 3D Gaussian Splatting, the explicit scene representation that the method builds on for static scene rendering.","marker":"[23]"},{"why":"4D Gaussian Splatting, the dynamic-scene backbone using hexplane-based deformation that ZDySS trains on top of.","marker":"[63]"},{"why":"Feature 3DGS supplies the per-Gaussian feature vectors and the feature-map renderer used to lift 2D VGG features into the 3D scene.","marker":"[74]"},{"why":"AdaIN provides the style transfer operation and the pretrained decoder that turns stylized feature maps into images.","marker":"[18]"},{"why":"VGG is the frozen pretrained encoder that supervises the per-Gaussian feature vectors and supplies feature statistics for stylization.","marker":"[55]"},{"why":"HexPlane is the space-time representation that 4DGS uses to compute per-timestamp Gaussian deformations.","marker":"[4]"},{"why":"S-DyRF is the per-style optimization baseline that the method compares against on dynamic scene stylization.","marker":"[28]"},{"why":"StyleDyRF is the zero-shot NeRF baseline whose learned stylization MLP requires a large style dataset, the contrast the paper highlights.","marker":"[67]"},{"why":"Plenoptic Video Dataset provides the multi-view dynamic scenes used for training and evaluation.","marker":"[26]"}],"fun_headline_variants":["Zero-shot restyling for dynamic scenes, no retraining","Any style, any frame: zero-shot dynamic scene stylization","Stylize moving scenes on the fly with zero-shot Gaussian splatting","Dynamic scenes adopt any style instantly, no retraining"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The method assumes that the learned per-Gaussian features are stable enough across all views and timestamps that a single global set of normalization statistics from training time remains appropriate for every rendering at inference.","fun_headline_variants_meta":{"raw":{"variants":["Zero-shot restyling for dynamic scenes, no retraining","Any style, any frame: zero-shot dynamic scene stylization","Stylize moving scenes on the fly with zero-shot Gaussian splatting","Dynamic scenes adopt any style instantly, no retraining"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000209,"raw_usage":{"total_tokens":1371,"prompt_tokens":873,"completion_tokens":498,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":489,"completion_tokens_details":{"reasoning_tokens":426}},"tokens_in":489,"tokens_out":498,"duration_ms":4725,"temperature":1.0,"reasoning_tokens":426,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-10T21:44:00.998975+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Render held-out views and timestamps from a trained scene and compute the actual mean and standard deviation of each rendered feature map; if those per-image statistics deviate sharply from the training-time running average in a way that produces visible flicker, color shifts, or lost style detail over longer time gaps, the core claim fails. A concrete test would use a scene with a large moving object or changing illumination and compare ZDySS with per-image AdaIN normalization on long-range temporal consistency.","supporting_citations":[{"cited_title":"4d gaussian splatting for real-time dynamic scene rendering","cited_arxiv_id":null,"evidence_quote":"4D Gaussian Splatting, the dynamic-scene backbone using hexplane-based deformation that ZDySS trains on top of."},{"cited_title":"Feature 3dgs: Supercharging 3d gaussian splatting to enable distilled feature fields","cited_arxiv_id":null,"evidence_quote":"Feature 3DGS supplies the per-Gaussian feature vectors and the feature-map renderer used to lift 2D VGG features into the 3D scene."},{"cited_title":"Arbitrary style transfer in real-time with adaptive instance normalization","cited_arxiv_id":null,"evidence_quote":"AdaIN provides the style transfer operation and the pretrained decoder that turns stylized feature maps into images."},{"cited_title":"Hexplane: A fast representa- tion for dynamic scenes","cited_arxiv_id":null,"evidence_quote":"HexPlane is the space-time representation that 4DGS uses to compute per-timestamp Gaussian deformations."},{"cited_title":"S-dyrf: Reference-based styl- ized radiance fields for dynamic scenes","cited_arxiv_id":null,"evidence_quote":"S-DyRF is the per-style optimization baseline that the method compares against on dynamic scene stylization."},{"cited_title":"Neural 3d video synthesis from multi-view video","cited_arxiv_id":null,"evidence_quote":"Plenoptic Video Dataset provides the multi-view dynamic scenes used for training and evaluation."}],"review_version":1}