We appreciate the reviewer’s valuable feedback and thoughtful questions. We will correct the formatting issues and incorporate the relevant related work in the revised version. Below, we address the discussion points in detail.

W1&Q1: Comparison with SplatFormer

We respectfully note that SplatFormer is discussed and cited in line 201. However, we are happy to further elaborate here and will expand the discussion in the related work section of the revised version. Notably, our design yields two significant benefits:

Fusion capability and applicability to dynamic scenes: Our fuse-and-refine sparse voxel transformer is capable of fusing and refining an arbitrary number of input primitives into a fixed number of output tokens. In contrast, SplatFormer uses a Point Transformer that outputs the same number of Gaussian primitives as its input, without fusing nearby points spatially. As a result, SplatFormer is not suitable for online streaming reconstruction tasks, as it cannot fuse redundant primitives over time. Our hybrid splat-voxel representation supports efficient and flexible fusion in both space and time, a capability that SplatFormer's purely point-based design cannot support.

Effectively Handling of unbounded scene: SplatFormer’s Point Transformer is sensitive to the spatial distribution of input points and is primarily designed for object-centric settings. According to its original paper, SplatFormer demonstrates limited scalability when applied to large, unbounded scenes. Its uniform downsampling strategy in the point Transformer disproportionately reduces the resolution of foreground objects relative to expansive backgrounds, making it challenging to preserve fine-grained details in complex environments. In contrast, our method employs a coarse-to-fine voxel hierarchy, with the depth dimension of the voxels representing equal increments in disparity, and prunes empty space where appropriate to reallocate compute to occupied regions. Our design enables effective and scalable reconstruction of unbounded scenes, while achieving significantly higher efficiency. When processing a similar number of primitives, our method completes a forward pass in under 15 ms, compared to over 100 ms for SplatFormer.

W2&Q2: Better Improvement on Dynamic Scenes

When applied to dynamic scenes, our fusion-and-refine module operates in both spatial and temporal domains. In addition to the multi-view spatial fusion-and-refinement also used in static scenes, it leverages temporal information by incorporating historical reconstructions. That said, the more pronounced improvements observed in dynamic scenes can be attributed to the combined effects of both spatial and temporal fusion, as demonstrated in the ablation study presented in Table 3. Specifically, adding the hybrid representation for spatial fusion and refinement without temporal information (Ours without History-aware Fusion) achieves a reconstruction PSNR of 27.17, compared to GS-LRM’s 21.80. This indicates that spatial fusion is the primary contributor to the overall improvement in reconstruction quality. However, this variant suffers from severe flickering artifacts due to the lack of temporal consistency, with a flicker score of 5.91 worse than GS-LRM’s 5.71. By incorporating temporal fusion, our full method further improves the reconstruction quality from 27.17 to 27.41 PSNR and significantly reduces flicker from 5.91 to 2.92. These results underscore the essential role of temporal fusion in maintaining temporal consistency, which is critical for high-quality dynamic scene reconstruction. Overall, we emphasize that the effectiveness of our fusion-and-refinement module lies in its ability to operate jointly across spatial and temporal domains, which is a key strength of our approach.

W3&Q3: Efficiency Analysis

Here, we present a detailed breakdown of the inference runtime of our method for both static scene and streaming reconstruction, evaluated on an NVIDIA H100 GPU. We begin by reporting the runtime of individual components for static scene reconstruction on the RealEstate10K dataset, using two input views at a resolution of 256×256.

Table: Runtime Breakdown of Static Scene Reconstruction on the RealEstate10K Dataset

We further analyze the runtime of each component in a streaming reconstruction setting on the Neural3DVideo dataset, using 2 input views at a resolution of 320×240. Note that 2D tracking is applied only to keyframes, which are sampled every 5 frames.

Table: Runtime Breakdown of Streaming Reconstruction on the Neural3DVideo Dataset

The slight runtime overhead of our method compared to GS-LRM for static scene reconstruction can be mitigated by reducing the number of multi-view transformer layers in the GS-LRM backbone. As shown in Table 1 of our paper, our method improves PSNR by over 2 dB while maintaining comparable model size and inference time.

For streaming reconstruction, the primary bottlenecks are the 2D tracking and 3D warping modules. We believe that adopting a faster 2D tracking backbone and exploring more advanced 3D warping strategies beyond our current simple warping algorithm represent promising directions for future work.

W4&Q4: Integration with Other frameworks

Our method can be naturally integrated with other feed-forward 3D Gaussian Splatting frameworks. Since the fuse-and-refine module directly operates on 3D primitives, it can be seamlessly plugged into the training pipelines of various feed-forward methods. In this paper, we choose GS-LRM as the backbone due to its state-of-the-art performance among existing feed-forward methods (see Table 2 of our paper). Due to time constraints, we were unable to include experiments with alternative backbones in the rebuttal. However, we plan to explore such integrations to further demonstrate the generalizability of our approach.

W5: Occlusion Handling and Temporal Consistency

We evaluate temporal consistency using the flicker metric, as described in Line 270 of the paper. As shown in Table 4, our method achieves the highest reconstruction quality while maintaining strong temporal consistency. A key challenge in evaluating occluded regions is obtaining accurate occlusion masks. We would be happy to include this metric and would appreciate any suggestions for generating reliable masks in sparse, in-the-wild videos.

As illustrated in Figure 4, GS-LRM struggles to reconstruct the window due to occlusion by the person. In contrast, our method achieves consistent reconstruction by leveraging historical information to effectively handle occlusions, as also shown at 2:00 in the supplementary video.

W6: Clarification of Technical Terms

We thank the reviewer for pointing out these unclear terms and will revise them accordingly. The term history-aware streaming reconstruction refers to leveraging information from past frames to enhance the reconstruction of new frames in arbitrarily sparse-view, long streaming inputs, thereby improving both quality and temporal stability.
The feature vector $F_k$ is introduced in Line 135 as additional splat features derived from the image to enhance the fuse-and-refine module. Its effect is analyzed in paper Table 1 under the ablation setting "Ours (w/o Splat Feature)."

W7: Interpretability Analysis of the Fuse-and-refine Strategy

The motivation behind our learning-based fusion strategy is to merge redundant primitives across both spatial views and temporal frames. As discussed in Line 140, deriving an analytical solution for fusing Gaussian primitives is highly challenging. Our fuse-and-refine approach addresses this by learning a global fusion mechanism from large-scale data using a voxel Transformer backbone. Given a set of initial Gaussian primitives, we aggregate local features from Gaussian primitives into a voxel representation, and then apply the Transformer to generate refined Gaussian primitives from voxel features. Through end-to-end training with photometric rendering supervision, the module is optimized to refine imperfect primitives into a set of high-quality Gaussians. We empirically validate the effectiveness of our fusion strategy through comparisons with GS-LRM in both static and streaming scene reconstruction, and present a comprehensive ablation study of its design components in paper Table 1.

Our voxel sparsification strategy is motivated by the observation that large-scale unbounded scenes are typically sparse. The sparsification ratio (20% threshold) is chosen to keep the number of tokens below 10K, ensuring that the transformer runs within 15 milliseconds. In practice, we find that a sparsification ratio between 15% and 25% offers a good balance between performance and quality. A promising direction for future work is to develop a more adaptive, scene-aware pruning strategy.

The error-aware fusion module is designed to filter out primitives with large warping errors by comparing the rendered results of warped primitives against ground truth. We demonstrate the efficacy of this module in paper Table 3. Since useful primitives generally produce low errors, they are more likely to be preserved. Additionally, trained on large-scale datasets with diverse types of Gaussian primitive inputs, our learned fuse-and-refine strategy demonstrates robustness to variations in input primitives.

W8: Runtime GPU Memory

Our method consumes approximately 10 GB of GPU memory during inference, primarily due to the naive implementation of voxel grid storage. This can potentially be optimized by adopting a sparse data structure.

We thank the reviewer for their valuable comments and appreciation of our fuse-and-refine module. Below, we address the noted weaknesses.

W1: Visual Improvement

We observe that the key visual advantage of our method over GS-LRM lies in its ability to better preserve fine details in thin structures, whereas GS-LRM often produces blurrier edges (e.g., the chair backrest case). Additional qualitative results are presented on the DL3DV dataset in Figure 9 and the RealEstate10K dataset in Figure 10, where our method consistently outperforms GS-LRM in terms of both geometric accuracy and appearance fidelity, producing sharper boundaries and more fine-grained structural details. This advantage also extends to streaming reconstruction scenarios, as illustrated in Figure 4 and the close-up examples in Figure 8. Quantitative metrics and visual comparisons alike further support the effectiveness of our fuse-and-refine module in enhancing reconstruction quality.

W2: End-to-end Training

We thank the reviewer for this valuable comment. Our approach supports end-to-end training together with the per-pixel primitive prediction backbone, such as the multi-view transformer used in GS-LRM. Below, we show results on the DL3DV dataset using end-to-end training from scratch for 200K iterations. We compare this to the staged training strategy in Table 1 of the paper, where the multi-view transformer is first trained alone for 100K iterations, then jointly trained with our fuse-and-refine module for another 100K iterations. To ensure a fair comparison in model capacity, both variants of our method use a 12-layer multi-view transformer, whereas GS-LRM employs a 24-layer transformer and is trained for 200K iterations.

These results demonstrate that end-to-end training yields further improvements in performance.

W3: Comparison with voxel-based point-cloud networks

We thank the reviewer for the insightful suggestion regarding the connection to voxel-based point cloud networks. In the revised version, we will include a thorough discussion and citations of relevant voxel-based methods, and we would also like to highlight two key advantages of our approach over existing techniques.

Fine-grained Reconstruction in Unbounded Scene: Voxel-based point cloud methods typically convert irregular point sets into uniform grids to enable structured operations such as 3D convolutions [1,2]. While effective for object-level 3D perception tasks, these approaches struggle to scale to large, unbounded environments. Bird’s Eye View (BEV) representations have been adopted in autonomous driving to handle large-scale point clouds more efficiently [3]. However, by projecting the scene onto a top-down plane, BEV representations inherently sacrifice vertical resolution and full 3D geometry, limiting their applicability to general-purpose 3D reconstruction. In contrast, our method constructs a cost volume aligned with the target camera's normalized device coordinates (NDC), where the z-axis is parameterized linearly in disparity to enable finer modeling of near-field geometry. This voxel representation supports high-fidelity reconstruction across large, unconstrained scenes.

​​Global Perception Field: While attention mechanisms have been introduced to voxel-based point cloud networks to overcome the locality constraints of traditional 3D convolutions, most approaches [4,5] are still limited to local attention due to memory constraints. Full global attention over all voxels or points remains challenging especially for large-scale unbounded scenes. We address this challenge by introducing a coarse-to-fine voxel hierarchy that enables global attention at the coarsest level. This design facilitates efficient long-range context aggregation while capturing fine-grained details essential for large-scale scene modeling.

[1]: Zhou Y, Tuzel O. Voxelnet: End-to-end learning for point cloud based 3d object detection

[2]: Liu Z, Tang H, Lin Y, et al. Point-voxel cnn for efficient 3d deep learning

[3]: Li Z, Wang W, Li H, et al. Bevformer: learning bird's-eye-view representation from lidar-camera via spatiotemporal transformers

[4]: Mao J, Xue Y, Niu M, et al. Voxel transformer for 3d object detection

[5]: He C, Li R, Li S, et al. Voxel set transformer: A set-to-set approach to 3d object detection from point clouds

We thank the reviewer for recognizing our fuse-and-refine strategy, as well as for the constructive feedback regarding dynamic scene reconstruction and the suggestion to place greater emphasis on static scenes. Below, we address the discussion points in detail.

W1&W2&Limitation: Dynamic Scene Reconstruction

We would like to clarify that our application to dynamic scene reconstruction specifically focuses on sparse-view online streaming reconstruction, a particularly challenging and underexplored setting within the field. By achieving interactive reconstruction rates of 15 FPS from sparse-view, long streaming input, our method becomes highly applicable to online augmented and virtual reality scenarios. Existing methods fall short in this scenario: optimization-based methods such as 3DGS and 4DGS struggle with sparse-view inputs, face scalability issues with long video sequences, and fail to meet the reconstruction speed requirements of online applications; feed-forward approaches like GS-LRM do not leverage historical information to ensure temporal consistency, often leading to noticeable flickering artifacts.

Thanks to the reviewer's suggestion, we additionally apply 2D tracking and 3D warping to GS-LRM and present the results below. We use the same keyframing strategy as described in the paper, refreshing the warped primitives every 5 frames to mitigate error accumulation.

Table: Comparison for Adding 3D Warping to GS-LRM

The results highlight that leveraging historical information by directly applying 3D warping to per-frame reconstruction backbones is prone to error. Specifically, warping past reconstructions to later frames (GS-LRM + 3D Warping) leads to larger reconstruction errors, as it fails to handle newly appearing content and suffers from accumulated warping errors. Addressing these limitations is non-trivial. A simple fusion baseline (Concat + Dropout) incrementally adds new primitives while discarding 50% per frame to prevent unbounded growth in the number of primitives, but lacks refinement and often removes accurate primitives.

To overcome these challenges, we propose a novel fuse-and-refine mechanism. The module efficiently leverages historical information, functions at interactive rates, and does not require training on the currently limited multi-view temporal datasets. We believe this robust fusion strategy provides a compelling and practical solution to the challenges of online streaming reconstruction.

We also acknowledge the current limitations in performance, for example in the dynamic components as noted by the reviewer. We believe these challenges are due in part to our simple 3D warping strategy, which may have limited accuracy under the sparse-view setting. Future work could explore more advanced 3D warping backbones to address this issue, which is beyond the scope of this work. Due to the scarcity of available multi-view video data, we currently train our method only on static scenes. Nonetheless, the fuse-and-refine framework holds strong potential for training on dynamic scenes, which could further mitigate temporal artifacts in future work.

Limitation: Extended Evaluation for Static Scene Reconstruction

We appreciate the reviewer’s recognition of our method’s potential for static scene reconstruction. As shown below, our method outperforms recent feed-forward 3D Gaussian Splatting methods on RealEstate10K:

Table: Quantitative Comparison with Additional Baselines on the RealEstate10K Dataset

Our method also demonstrates strong generalization capability across varying input views. We compare it with Gaussian Graph Network, a state-of-the-art method for handling diverse input views through local primitive fusion using graph convolution. We follow its experimental setup to train the model with 2 input views and evaluate with 4 input views on the RealEstate10K dataset. As shown in the table below, our method not only significantly outperforms the Gaussian Graph Network but also maintains consistent reconstruction quality when generalizing from 2 to 4 input views.

Table: Comparison with Gaussian Graph Network on the RealEstate10K Dataset (2-view training, 4-view evaluation)

Our method also performs well on large unbounded scene datasets such as DL3DV. As shown in paper Table 1 and Appendix Figure 9, our fuse-and-refine approach significantly improves the reconstruction quality of GS-LRM, yielding a PSNR improvement of approximately 2dB while maintaining a comparable model size.

Trained with 4 input views on the DL3DV dataset, our method consistently outperforms GS-LRM across a wide range of input configurations as shown in the table below. Since input views are chosen based on proximity to the target, increasing from 4 to 16 introduces a distribution shift while contributing limited new information for target view rendering, which explains the performance drop in both methods. Nevertheless, our method maintains significantly better reconstruction quality than GS-LRM across all input settings. We believe these results further demonstrate the potential of our method to handle long sequence large scene reconstruction, as noted by the reviewer.

Table: Quantitative Comparison under Varying Numbers of Input Views on the DL3DV Dataset (4-view Training)

We would also be happy to include more evaluations on static scene reconstruction, and would appreciate it if the reviewer could suggest specific experimental setups.

Q1: Comparison with Splat-voxel Representations

We thank the reviewer for highlighting relevant voxel-splat representations and will include the following discussion in the revised related works section. SCube pretrains a voxel diffusion model using LiDAR and COLMAP point clouds from a self-driving dataset to infer voxel representations at inference. However, it is extremely slow (several seconds per frame) and not applicable to scenes like RealEstate10K that lack LiDAR input. In contrast, our method is trained using only RGB supervision. It also supports large-scale scene reconstruction such as DL3DV, and achieves significantly faster inference times of approximately 70 milliseconds per frame. Omni-Scene combines pixel-aligned Gaussians with Gaussians constructed from feature volumes, aiming to exploit the strengths of both pixel-based and volumetric representations. Unlike our method, this design is not easily extendable to dynamic scenes. Additionally, both SCube and Omni-Scene rely on 3D CNNs to process voxel features in a tractable manner, but this design leads to limited perceptual fields. In contrast, our approach introduces an efficient coarse-to-fine voxel hierarchy, allowing us to directly perform full self-attention over the input tokens. As shown in the comparison on the RealEstate10K dataset above, our method significantly outperforms Omni-Scene and achieves state-of-the-art performance.

Q2: Runtime Breakdown

The runtime reported in paper Table 4 includes both 3D warping and 2D tracking times. 2D tracking is applied only to keyframes, sampled every 5 frames. Below, we provide a detailed runtime breakdown for both streaming and static scene reconstruction (tested on H100).

Table: Runtime Breakdown of Streaming Reconstruction on the Neural3DVideo Dataset

Table: Runtime Breakdown of Static Scene Reconstruction on the RealEstate10K Dataset

Q3: Performance of Converged 3DGS

The runtimes of 3DGS and 3DGStream reported in paper Table 4 include both training and rendering times. We apply early termination during training due to a severe overfitting problem observed in 3DGS under the sparse-view setup. To illustrate this, we show the training and validation PSNR curves for 3DGS on a single frame from the 2-view Neural 3D Video dataset.

As shown in the table, validation PSNR peaks near 1000 iterations while training PSNR continues to rise, clearly indicating overfitting. This observation motivates our decision to limit training iterations. However, we are also happy to include the fully converged 3DGS and 3DGStream results using their original configurations in the revised version.

We appreciate the reviewer’s valuable feedback and their recognition of our method, especially its ability to generalize to streaming scene reconstruction. In the following, we address the identified weaknesses in detail.

W1: Discussion and Comparison with Related Work

We thank the reviewer for highlighting relevant works for comparison and discussion, which we will thoroughly incorporate into the revised version. Here, we outline the key advantages of our method over HiSplat and Gaussian Graph Network, both of which also explore aggregation strategies for Gaussian primitives.

HiSplat predicts multi-scale per-pixel Gaussian primitives and fuses these hierarchical predictions at each pixel location. However, the absence of a 3D canonical space for fusion limits its ability to generalize to temporal fusion of Gaussian primitives across frames, which our method is explicitly designed to support. Furthermore, our sparse voxel transformer learns an effective global strategy using full attention. This results in substantially improved performance on the RealEstate10K dataset (shown in the table below) compared to the local per-pixel fusion approach in HiSplat. Gaussian Graph Network fuses per-pixel primitives using graph convolutions over local neighborhoods, but its scalability is limited since the number of edges grows quadratically with the number of input primitives. By transferring an arbitrary number of primitives into a fixed voxel representation, our voxel transformer maintains constant processing time regardless of input size. Moreover, graph convolutions are inherently limited by their local receptive fields, making it difficult to capture the global organization of primitives. Our approach overcomes these limitations by leveraging full attention within the voxel transformer to aggregate information across the entire scene, enabling long-range context modeling and global structural fusion and refinement.

We also include a quantitative comparison with more recent feed-forward 3D Gaussian Splatting methods including TranSplat, HiSplat, Omni-Scene on the RealEstate10K dataset. As shown below, our method achieves the best performance among all baselines, demonstrating its effectiveness. Since EvoSplat does not report results on RealEstate10K, we include Omni-Scene instead, a related method that similarly adopts a voxel-splat representation for enhancing driving scenarios.

Table: Additional Baseline Comparisons on the RealEstate10K Dataset

We also compare our method with Gaussian Graph Network on the RealEstate10K dataset, following its experimental configuration. Both models are trained with 2 input views and evaluated with 4 input views to assess generalization across varying input configurations. As shown in the table below, our method significantly outperforms this state-of-the-art Gaussian fusion approach.

Table: Comparison with Gaussian Graph Network on the RealEstate10K Dataset (2-view training, 4-view evaluation)

Due to time constraints, we could not include recent streaming methods like HiCoM in the rebuttal, but we will add them in the revision. HiCoM, like 3DGStream, is designed for dense-view input and performs poorly under sparse views. While faster than 3DGStream, it still takes over 1 second per frame, making it unsuitable for online reconstruction. In contrast, our method runs at 0.07 seconds per frame.

W2: Efficiency Analysis

We present a detailed breakdown of the inference runtime of our method, evaluated on an NVIDIA H100 GPU. We first report the runtime breakdown for static scene reconstruction on RealEstate10K using two input views at 256×256 resolution.

Table: Runtime Breakdown of Static Scene Reconstruction on the RealEstate10K Dataset

We further analyze the runtime of each component in a streaming reconstruction setting on the Neural3DVideo dataset, using 2 input views at a resolution of 320×240. Note that 2D tracking is applied only to keyframes, which are sampled every 5 frames.

Table: Runtime Breakdown of Streaming Reconstruction on the Neural3DVideo Dataset

We also present an inference time comparison between our method and other feed-forward Gaussian Splatting approaches, including PixelSplat, MVSplat, and GS-LRM, on the RealEstate10K dataset. All runtimes were measured on an NVIDIA A100 GPU.

Table: Inference Time Comparison on the RealEstate10K Dataset

The slight runtime overhead of our method compared to GS-LRM can be mitigated by reducing the number of multi-view transformer layers. As shown in Table 1 of our paper, our method improves PSNR by over 2 dB while maintaining comparable model size and inference time.

Q1&Q3: Effect of Voxel Sparsification and Applying Transformer on Fine-level voxels

The primary goal of voxel sparsification is to reduce the number of input tokens for the voxel transformer. Without sparsification, the token count would scale cubically with the voxel dimensions, with excessive GPU memory usage and slow compute speed. Relatedly, applying the transformer on coarse-level voxels also helps to reduce token count, whereas directly applying the transformer on fine-level voxels becomes infeasible unless we reduce voxel resolution which harms reconstruction quality. While the reviewer is correct that culling the fine voxels can improve rendering speed by reducing the final number of primitives, our coarse-level sparsification achieves two goals: reduceing the final primitive count and making the voxel transformer tractable.

As shown in Table 1, we include ablation studies for the setting without voxel sparsification (Ours (w/o Coarse-to-Fine)). Due to memory constraints, we reduce the voxel resolution by 75% in this setting, which still results in slower inference and degraded reconstruction quality. Similarly, in the variant without the coarse-to-fine hierarchy (Ours (w/o Coarse-to-Fine)), the voxel transformer is applied only at a single voxel level. Applying the transformer directly on dense-level voxels would require an even greater reduction in resolution due to memory limitations, leading to significantly worse results.

Q2&Q4: Sparsification Ratio and Token/Primitive Numbers

We apologize for the typo in the abstract regarding the number of primitives. The correct number is 200K (as stated in line 57). The number of primitives and tokens is calculated as follows: given 2 to 4 input views with a resolution of 384 × 216, GS-LRM generates multi-view per-pixel primitives (2~4 × 384 × 216), resulting in approximately 165K to 330K primitives. For these primitives, Our splat-to-voxel transfer converts them into a coarse voxel grid with a resolution of (384 / 8) × (216 / 8) × 32. We then sparsify the grid based on voxel opacity and retain only the top 20%, yielding roughly 8K tokens for the transformer input. This voxel transformer takes approximately 15 milliseconds for the forward pass, as shown in the breakdown above.

The sparsification ratio (20% threshold) is chosen to keep the number of tokens below 10K, ensuring that the transformer runs within 15 milliseconds. Although using a higher sparsification ratio can further improve speed, it risks discarding useful information. Conversely, a lower ratio increases token count and slows down inference. In practice, we find that a sparsification ratio between 15% and 25% offers a good balance between performance and quality. We also observed that sparsity is common in large-scale unbounded scene modeling, with typically fewer than 30% of voxels having a primitive opacity greater than 0.005.

Q5&Q6: Keyframing

We select a keyframe every 5 frames to run the 2D tracking model, which takes approximately 0.28 seconds and provides tracking results for the following 5 frames. Only two keyframes are maintained during streaming reconstruction to ensure efficiency.

As expected, non-keyframe frames may exhibit slightly reduced performance compared to keyframes due to accumulated 3D warping errors. However, we report the average performance over the entire sequence in paper Table 4, which reflects the practical effectiveness of our method under the streaming setting.

Q7: Monocular Input

Our method currently does not support monocular streaming, as the GS-LRM backbone requires at least two input views to produce reliable Gaussian primitives. However, with a reliable single-view Gaussian Splatting predictor, our framework could naturally be extended to support monocular reconstruction.

Limitation

We acknowledge that coarse-level pruning may introduce “dead regions” in the reconstruction. However, we observe that typical 3D scenes do contain large regions of empty space, and our pruning step exploits this fact to improve processing efficiency. We currently use a simple heuristic, assuming a fixed sparsity ratio of 20%, but a potential direction for future work is a more adaptive and scene-aware pruning strategy.