A 3D Gaussian sputtering compression method and system based on residual quantization and dynamic pruning

Abstract

This invention belongs to the field of computer graphics and real-time 3D scene reconstruction technology, and relates to a real-time compression and optimization method based on 3D Gaussian Splatting (3DGS) models. Through residual vector quantization (RVQ) and dynamic pruning techniques, it achieves efficient storage, transmission, and rendering of 3D scenes, including: S1, residual vector quantization; S2, dynamic pruning strategy enhancement; S3, index compression and encoding optimization. This invention proposes a real-time 3D Gaussian Splatting model compression system combining residual vector quantization and dynamic pruning, which can achieve high-quality real-time rendering and extremely high storage efficiency. Through three core technologies—vector quantization strategy, dynamic pruning strategy enhancement, and index compression and encoding optimization—it achieves the goal of reducing model storage by more than 45 times and increasing rendering speed by 3 times while ensuring rendering quality.

Description

A 3D Gaussian sputtering compression method and system based on residual quantization and dynamic pruning Technical Field

[0001] This invention belongs to the field of computer graphics and real-time 3D scene reconstruction technology, and relates to a real-time compression and optimization method based on a 3D Gaussian sputtering (3DGS) model. Through residual vector quantization (RVQ) and dynamic pruning techniques, it achieves efficient storage, transmission and rendering of 3D scenes. Background Technology

[0002] While the original 3D Gaussian Splatter (3DGS) technology has demonstrated significant advantages in real-time rendering, its practical applications face multiple technical bottlenecks: In terms of storage efficiency, the large parameter size of a single scene (e.g., the truck scene in the Tanks & Temples dataset reaches 4.2GB) far exceeds the carrying capacity of low-end devices, necessitating resolution compression from 4K to 720p for hardware compatibility during actual deployment; this results in a severe waste of storage space and network bandwidth. Regarding quantization methods, existing solutions use full-precision 32-bit floating-point storage. Experiments show that only 4-bit quantization is needed for opacity parameters to meet perception requirements (PSNR loss <0.3dB), while forced 8-bit uniform quantization leads to the loss of high-frequency geometric features (e.g., the SSIM value of building edges drops to 0.82). Practical applications are limited; in cloud rendering scenarios, the loading latency of a 1GB model exceeds 8 seconds (100Mbps bandwidth), failing to meet the real-time interactive needs of AR navigation, and parameter updates lack a compressed perception mechanism, with dynamic editing latency accounting for over 40%. These shortcomings severely restrict the practical application of 3DGS technology in mobile devices, XR devices, and real-time streaming media.

[0003] Based on the above analysis, the urgent technical problems that need to be solved in the existing technology are:

[0004] (1) In terms of storage efficiency, the scale of parameters in a single scene is relatively high (such as the storage of truck scenes in the Tanks & Temples dataset reaching 4.2GB), which far exceeds the carrying capacity of low-end devices, resulting in the need to compress the resolution from 4K to 720p to adapt to the hardware during actual deployment; causing a serious waste of storage space and network transmission bandwidth.

[0005] (2) In terms of quantization methods, existing solutions use full-precision 32-bit floating-point storage. Experiments show that the opacity parameter only needs 4-bit quantization to meet the perception requirements (PSNR loss <0.3dB), while forced 8-bit uniform quantization will lead to the loss of high-frequency geometric features (such as the SSIM value of building edges dropping to 0.82). Practical applications are limited. In cloud rendering scenarios, the loading delay of a 1GB model exceeds 8 seconds (100Mbps bandwidth), which cannot meet the real-time interaction requirements such as AR navigation. Moreover, parameter updates lack a compressed perception mechanism, and the dynamic editing latency accounts for more than 40%. Summary of the Invention

[0006] To address the problems existing in the prior art, this invention provides a 3D Gaussian sputtering compression method and system based on residual quantization and dynamic pruning.

[0007] This invention is implemented as follows: a 3D Gaussian sputtering compression method based on residual quantization and dynamic pruning, comprising:

[0008] S1, Residual Quantization Vector Quantization;

[0009] S2, enhanced dynamic pruning strategy;

[0010] S3, index compression and encoding optimization.

[0011] S1 specifically includes:

[0012] 1. Parameter grouping and dynamic codebook allocation:

[0013] Input: Original Gaussian parameters (position, color SH coefficient, covariance rotation / scale, opacity)

[0014] Parameter grouping: The color group is split into DC components (1D) and SH coefficients (15D), with the SH coefficients further divided into low-frequency (orders 1-3) and high-frequency (orders 4-15). The covariance group is split into rotated quaternions (4D) and logarithmic scales (3D).

[0015] 2. Information Entropy Calculation: Calculate the information entropy for each set of parameters:

[0016]

[0017] Parameter meaning:

[0018] x: Parameters to be compressed (such as color SH coefficients, covariance components, etc.).

[0019] p: The probability of a parameter value appearing in the dataset.

[0020] 3. Dynamic codebook allocation:

[0021]

[0022] Total codebook size (e.g., 32K). Size of the g-th codebook

[0023] 4. Residual Quantization (RVQ) and Mixed Precision Training:

[0024] For each set of parameters, initial quantization is performed using a low-bit codebook (4 bits, 16 centers):

[0025]

[0026] Residual calculation and secondary quantization:

[0027]

[0028] Where r (residual) is an 8-bit codebook (256 centers).

[0029]

[0030] Core idea: During training, quantizers of different precisions are jointly optimized, and the soft and hard quantization weights are controlled by temperature annealing to gradually converge to the optimal quantization result.

[0031] Temperature annealing weight formula

[0032]

[0033] Error of hard quantization (direct rounding)

[0034] Error of soft quantization (preserving floating-point residuals)

[0035] T: Temperature parameter, with a high initial value (e.g., 1.0) that gradually decreases to near 0 (e.g., 0.1).

[0036] 5. Output:

[0037] Quantization parameters:

[0038] Codebook data:

[0039] S2 specifically includes:

[0040] 1. Energy function calculation and threshold setting:

[0041] Input: Gaussian parameters and their multi-view visibility records during training.

[0042] Multifactor energy calculation:

[0043]

[0044] Opacity;

[0045] : The distance from Gauss to the origin of the scene;

[0046] The number of times Gauss is visible in the training perspective.

[0047] Dynamic threshold adjustment:

[0048] The average energy of all current Gaussians. The standard deviation is denoted as .

[0049] 2. Soft pruning and recovery mechanism:

[0050] Dormant flag: if Mark Gaussian i as hibernating (set) =0), retains the parameter but does not participate in rendering.

[0051] Region Loss Monitoring: The scene is divided into a 16×16×16 voxel mesh, and the rendering loss L region of the dormant Gaussian within each voxel is calculated. If the rendering loss L region > η in M ​​consecutive iterations, the dormant Gaussian within that region is awakened, triggering the recovery mechanism. Default M=10, η=0.05 (adjustable).

[0052] Gaussian Recovery: Awakens the dormant Gaussian within the voxel, resets σi to its initial value, and increases its energy weight α to 0.8 (to prevent it from being clipped again).

[0053] 3. Output: Pruned Gaussian set: Only retains active elements ( >0) and the restored Gaussian.

[0054] Hibernation pool: Stores hibernation Gaussian parameters for later recovery.

[0055] S3 specifically includes:

[0056] 1. Morton code sorting and differential coding

[0057] Input: Quantized Gaussian indices (integer sequence).

[0058] Coordinate normalization and Morton code calculation:

[0059] Normalize the Gaussian center coordinates [x,y,z] to the integer range [0,2^16−1] and calculate the three-dimensional Morton code.

[0060] Index sorting: Reorder the index in ascending order according to Morton code to generate an ordered sequence {I1, I2, ..., IN}.

[0061] Difference calculation:

[0062]

[0063] 2. Entropy Coding and Compression

[0064] Huffman code table generation:

[0065] statistics Frequency distribution, for high-frequency values ​​(such as...) ≤5) Allocate short codewords

[0066] Binary compression:

[0067] The differential sequence is converted into a Huffman-coded bit stream and then packaged and stored in big-endian order.

[0068] 3. Output: Compressed data: Huffman coding table + differentially coded bit stream.

[0069] Compression ratio: Reduced from 4 bytes / ID in the original index to an average of 0.5 bytes / ID (compression ratio of 85%).

[0070] A 3D Gaussian sputtering compression system based on residual quantization and dynamic pruning, which implements the aforementioned 3D Gaussian sputtering compression method, comprises:

[0071] The quantization module is used for residual quantization and vector quantization.

[0072] The strategy enhancement module is used to enhance dynamic pruning strategies.

[0073] The compression and optimization module is used for index compression and encoding optimization.

[0074] A computer device includes a memory and a processor. The memory stores a computer program, which, when executed by the processor, causes the processor to perform the steps of the 3D Gaussian sputtering compression method based on residual quantization and dynamic pruning.

[0075] A computer-readable storage medium storing a computer program, which, when executed by a processor, causes the processor to perform the steps of the described 3D Gaussian sputtering compression method based on residual quantization and dynamic pruning.

[0076] An information data processing terminal includes the aforementioned 3D Gaussian sputtering compression system based on residual quantization and dynamic pruning.

[0077] Based on the above technical solutions and the technical problems solved, the advantages and positive effects of the technical solution to be protected by this invention are as follows:

[0078] First, the correspondence between the core problems of existing technologies and the solutions of this invention:

[0079] 1. Storage efficiency bottleneck

[0080] Root cause of the problem: The original 3DGS model has a large number of parameters, which low-end devices cannot handle, resulting in resolution compression and wasted bandwidth.

[0081] The solution proposed in this invention is Residual Vector Quantization (RVQ): Through two-stage quantization (4-bit coarse quantization + 8-bit residual quantization), the PSNR is improved by 0.2-0.3dB at the same bit rate, the quantization error is reduced by 50%, and the storage requirement is significantly reduced.

[0082] Dynamic codebook allocation: The codebook capacity is adaptively allocated according to the parameter entropy value (e.g., 16K codebook for high-frequency SH coefficients and only 4K for low-frequency coefficients), reducing redundant codewords.

[0083] Index compression optimization: Morton code sorting + differential Huffman coding reduces the index size by 85%, achieving a compression rate of 85%.

[0084] 2. The contradiction between quantization accuracy and loss of detail

[0085] Root cause of the problem: The existing 8-bit uniform quantization causes the loss of high-frequency geometric features (such as the SSIM value of building edges dropping to 0.82).

[0086] Solution of this invention:

[0087] Residual quantization compensation: Secondary quantization is performed on the high-frequency components of color SH to preserve high-frequency details, reduce quantization error by 50%, and reduce PSNR by only 0.07dB (original 27.42dB on Tanks & Temples dataset → 27.35dB in this invention).

[0088] Hybrid precision codebook: dynamically balances accuracy and efficiency, improves backpropagation speed by 15%, and supports low-end device adaptation.

[0089] 3. Insufficient rendering speed and real-time performance

[0090] The root cause of the problem is that the original 3DGS rendering speed is 134FPS (1080p), which cannot meet the real-time interactive needs of AR navigation and other applications.

[0091] Solution of this invention:

[0092] Dynamic pruning strategy: By pruning 70% of low-contribution Gaussians through the energy function, the amount of rasterization calculation is reduced, and the rendering speed is increased to 412FPS (3 times faster).

[0093] Hardware-friendly encoding: Morton codes are sorted and stored in contiguous indexes, improving GPU cache hit rate and increasing decoding speed by 40%.

[0094] 4. High latency in dynamic editing

[0095] Root cause of the problem: The parameter update lacks a compressed sensing mechanism, and the dynamic editing latency accounts for more than 40%.

[0096] Solution of this invention:

[0097] Soft pruning and recovery mechanism: The probability of accidentally deleting key Gaussian elements is reduced by 80%, and details are dynamically recovered through regional loss monitoring to ensure real-time editing.

[0098] Progressive quantization training: Initially, quantization is avoided to prevent interference with parameter convergence; later, the quantization intensity is gradually increased, reducing codebook update frequency by 30%.

[0099] Secondly, this invention employs Residual Vector Quantization (RVQ), dynamic codebook allocation, and index optimization to achieve a 45x compression ratio, effectively reducing the storage requirements of 3DGS (3D Gaussian Splatting) models. For example, in the kitchen scene of the Mip-NeRF 360 dataset, the original model size was compressed from 440MB to 18.9MB, greatly alleviating the storage bottleneck of low-end devices. Furthermore, dynamic codebook allocation avoids overfitting / underfitting problems that may result from fixed allocation, ensuring that the compression method maintains a stable compression ratio and high fidelity in both urban scenes (high geometric complexity) and indoor scenes (high material detail).

[0100] Compared to existing methods, this invention maintains high-frequency textures and edge sharpness to the greatest extent possible during compression. On the Tanks & Temples dataset, the PSNR (Peak Signal-to-Noise Ratio) of this invention is 27.35dB, superior to CompGS's 26.97dB, with a PSNR decrease of only 0.07dB. Meanwhile, the SSIM and LPIPS metrics are close to the original model, ensuring near-lossless visual quality. Furthermore, the soft pruning recovery mechanism introduced in this invention effectively reduces the probability of accidentally deleting key Gaussian elements, ensuring rendering quality in complex scenes.

[0101] By optimizing the computational process, the rendering speed of this invention is increased to 412 FPS (1080p), far exceeding the original 3DGS's 134 FPS, meeting the real-time rendering requirements of AR / VR scenarios. Furthermore, this method can achieve 1080p@62 FPS on low-end graphics cards (such as NVIDIA GTX1050 Ti, 4GB), with a memory usage of only 3.2GB. Compared to traditional methods that rely on high-end GPUs, this invention achieves stronger hardware compatibility through hierarchical memory management, computational pipeline decomposition, and dynamic power consumption control, enabling low-end devices to run high-quality 3DGS rendering.

[0102] This invention reduces the number of codebook updates through progressive quantization training, shortening training time by 20%, while simultaneously improving backpropagation speed by combining mixed-precision codebooks. Furthermore, the proposed multi-factor energy function pruning strategy can adapt to optimization needs in different scenarios, ensuring stable rendering performance even in complex scenes.

[0103] This invention outperforms CompGS in several core technical dimensions. Regarding quantization strategies, this invention employs RVQ + dynamic codebook allocation, while CompGS uses K-means clustering + fixed codebook, resulting in insufficient generalization ability. In terms of pruning mechanisms, this invention's energy function-driven soft pruning combined with spatially aware recovery more accurately preserves key Gaussian elements compared to CompGS's hard threshold pruning. Regarding index compression, this invention utilizes Morton code sorting + Huffman coding to achieve an 85% compression rate, superior to CompGS's run-length encoding (RLE). Ultimately, it achieves 45x storage compression and 3x speed improvement, while CompGS only achieves 40-50x storage compression and 2-3x speed improvement.

[0104] This invention minimizes quality loss while compressing storage. Compared to CompGS's PSNR decrease of approximately 0.3dB, this invention's PSNR decreases by only 0.07dB, ensuring the integrity of high-frequency details. Furthermore, this method offers better compatibility with low-end devices, achieving CUDA utilization of up to 90% and enabling efficient operation on devices with ≤4GB of VRAM. CompGS, on the other hand, relies on high-end GPUs, limiting its application on ordinary hardware. This invention outperforms existing technologies in terms of storage efficiency, rendering quality, real-time performance, hardware compatibility, and training optimization, providing a superior solution for the application of 3DGS in real-world scenarios.

[0105] Third, as supplementary evidence of the inventive step of the claims of this invention, it is also reflected in the following important aspects:

[0106] The technical solution of this invention overcomes technical bias:

[0107] This invention overcomes long-standing technical biases in 3D model compression by employing innovative residual vector quantization, dynamic pruning strategies, and index compression optimization. Traditional techniques generally consider high-bit quantization the only way to guarantee rendering quality, while this invention proposes a 4-bit coarse quantization combined with 8-bit residual quantization. Through a residual compensation mechanism, it achieves a 0.2-0.3dB improvement in PSNR and a 50% reduction in quantization error at low bit-level quantization, demonstrating a non-linear balance between compression and quality. Addressing the bias that pruning inevitably leads to irreversible quality loss, this invention constructs a multi-factor energy function-driven dynamic pruning and spatially-aware recovery closed loop. By dynamically waking up dormant Gaussians through voxel-level loss monitoring, it reduces the false deletion rate by 80% with only a 0.07dB PSNR loss. In terms of hardware adaptation, it breaks the conventional wisdom that "real-time rendering depends on high-end GPUs." Through hierarchical memory management, computational pipeline decomposition, and Morton code optimization, it achieves 1080p rendering on low-end graphics cards with ≤4GB of memory, achieving 90% CUDA utilization. Furthermore, it overturns the traditional notion that index compression rates are difficult to exceed 65%. Overcoming the limitations of traditional methods, Morton code sorting and differential Huffman coding are adopted, compressing the index volume by 85%, laying the foundation for the large-scale application of 3D Gaussian sputtering technology in mobile devices, XR devices, and real-time streaming media. Attached Figure Description

[0108] Figure 1 is a flowchart of the 3D Gaussian sputtering compression method based on residual quantization and dynamic pruning provided in an embodiment of the present invention;

[0109] Figure 2 is a structural diagram of the 3D Gaussian sputtering compression system based on residual quantization and dynamic pruning provided in an embodiment of the present invention;

[0110] Figure 3 is a flowchart of the dynamic pruning and updating process provided in an embodiment of the present invention;

[0111] Figure 4 is a flowchart of an embodiment provided by the present invention;

[0112] Figure 5 is a comparison chart of the effects of various methods provided in the embodiments of the present invention;

[0113] Figure 6 is a comparison of Gaussian scene compression before and after the present invention. Detailed Implementation

[0114] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the invention.

[0115] The working principle of the 3D Gaussian sputtering compression method based on residual quantization and dynamic pruning.

[0116] 1. Overview and Working Principle

[0117] This method aims to efficiently compress 3D Gaussian sputtering representations to reduce storage and computational requirements while maintaining high-quality rendering. The core idea is to combine residual quantization (RVQ), dynamic pruning, and index optimization strategies to improve data compactness, reduce storage bandwidth, and optimize rendering computation. It mainly consists of three stages: S1 (Residual Quantization Vector Quantization), S2 (Dynamic Pruning Strategy), and S3 (Index Compression and Encoding Optimization). The entire process significantly reduces redundant Gaussian data and improves storage and rendering efficiency in 3DGS rendering tasks.

[0118] 2. Residual Quantization and Mixed Precision Training (S1)

[0119] (1) Parameter grouping and dynamic codebook allocation

[0120] Before quantization, the Gaussian parameters are first grouped, such as color, covariance, and spatial coordinates, to optimize compression efficiency. For example:

[0121] Color is split into DC components and SH coefficients (low and high frequencies are separated).

[0122] The covariance matrix is ​​decomposed into a rotated quaternion and a logarithmic scale.

[0123] Calculate the information entropy of each set of parameters and allocate codebook capacity accordingly to ensure that more important information is quantized with higher precision.

[0124] (2) Residual Quantization (RVQ)

[0125] First, coarse quantization is performed using a low bit-rate codebook (e.g., 4 bits, 16 centers), and the residual is calculated. Then, a second quantization is performed on the residual using a higher precision codebook (e.g., 8 bits, 256 centers) to further reduce the error.

[0126] (3) Mixed precision training

[0127] To dynamically adjust the quantization strategy during training, a temperature annealing mechanism is introduced:

[0128] Initially (T=1.0), soft quantization is used to preserve floating-point residuals and avoid premature convergence.

[0129] In the later stages of training (T→0.1), we gradually shift to hard quantization to improve the model's storage and computation efficiency.

[0130] Ultimately, the output of this stage is the quantized parameters and the corresponding codebook data, which are used for subsequent storage and indexing optimization.

[0131] 3. Enhanced dynamic pruning strategy (S2)

[0132] (1) Energy function calculation and dynamic pruning

[0133] Calculate the energy of each Gaussian, including opacity ( ), distance from Gaussian to the origin, and visibility in multiple viewpoints.

[0134] A dynamic threshold adjustment mechanism is adopted, which adaptively determines the pruning threshold based on the mean and standard deviation of the energy of all Gaussians, ensuring that only Gaussian points with low contribution are removed.

[0135] (2) Soft pruning and recovery mechanism

[0136] Sleep flag: If a Gaussian energy is less than a set threshold, it will temporarily sleep and not participate in rendering calculations, but its parameters will still be retained.

[0137] Region loss monitoring: The scene is divided into a 16×16×16 voxel mesh, and the rendering loss of each region (L_region) is monitored. If the loss exceeds a certain threshold in M ​​consecutive iterations (default 10 iterations), the dormant Gaussian in that region is awakened.

[0138] Gaussian recovery: For the awakened Gaussian, readjust its opacity ( ), and assign a higher energy weight. (Default 0.8) to avoid repeated pruning.

[0139] The final output is an optimized Gaussian set, which effectively reduces unnecessary computation while retaining key visual information.

[0140] 4. Index Compression and Encoding Optimization (S3)

[0141] (1) Morton code sorting and differential coding

[0142] To optimize data storage and indexing:

[0143] First, normalize the Gaussian's three-dimensional coordinates (x, y, z) to the integer range [0, 2^16−1], and then calculate its three-dimensional Morton code for spatial sorting.

[0144] By sorting the Gaussian index using Morton codes, adjacent data storage becomes more compact, improving the efficiency of local access.

[0145] Calculate the differential encoding of the index to further reduce storage redundancy.

[0146] (2) Entropy coding and compression

[0147] By statistically analyzing the frequency distribution of the difference sequence, Huffman coding is used to assign short codewords to high-frequency values, thereby further reducing data storage costs.

[0148] Differential encoded bitstreams are converted to big-endian storage format, ultimately improving data compression rate from 4 bytes / ID in the original index to an average of 0.5 bytes / ID.

[0149] 5. Summary of Key Optimization Strategies

[0150] This method improves the storage and computation efficiency of 3D Gaussian sputtering data through three core optimization strategies:

[0151] (1) Residual Quantization (RVQ): A stepwise quantization strategy is adopted to maintain high accuracy while reducing the amount of data.

[0152] (2) Dynamic pruning: Based on an adaptive energy assessment mechanism, it effectively reduces redundant Gaussians and improves rendering speed.

[0153] (3) Index Compression: Using Morton code sorting, differential coding and entropy coding, storage requirements are greatly reduced.

[0154] 6. Expected Technical Effects and Application Scenarios

[0155] (1) Storage optimization

[0156] Using this method, the amount of Gaussian data stored is reduced by more than 60%, making it suitable for large-scale 3D scene storage and rendering.

[0157] (2) Improved computational efficiency

[0158] Thanks to pruning and indexing optimizations, rendering computation is reduced by 30%-50%, accelerating tasks such as NeRF scene rendering and 3D point cloud reconstruction.

[0159] (3) Adaptive pruning mechanism

[0160] This method can adaptively adjust the pruning strategy from different perspectives to achieve higher visual fidelity, and is applicable to fields such as AR / VR, autonomous driving, and game rendering.

[0161] This innovative method combines residual quantization, dynamic pruning, and index compression strategies to significantly reduce the storage requirements of 3D Gaussian sputtering data and optimize rendering computation efficiency. Compared with traditional methods, this method reduces storage usage by 60% and rendering computation by 30-50%, making it particularly suitable for applications such as high-efficiency 3D scene rendering, UAV image reconstruction, augmented reality (AR), and virtual reality (VR).

[0162] As shown in Figure 1, the 3D Gaussian sputtering compression method based on residual quantization and dynamic pruning includes:

[0163] S1: Residual quantization vector quantization, which groups the 3D Gaussian parameters and dynamically allocates the codebook capacity, reducing data storage usage through stepwise quantization;

[0164] S2: Enhanced dynamic pruning strategy, based on energy function calculation and visibility analysis, adaptively prunes redundant Gaussian points;

[0165] S3: Index compression and encoding optimization, using Morton code sorting, differential encoding and entropy encoding to improve data storage efficiency.

[0166] As shown in Figure 2, the 3D Gaussian sputtering compression system based on residual quantization and dynamic pruning includes:

[0167] The quantization module is used for residual quantization and vector quantization.

[0168] The strategy enhancement module is used to enhance dynamic pruning strategies.

[0169] The compression and optimization module is used for index compression and encoding optimization.

[0170] 7. Complete process of residual quantization and vector quantization strategy

[0171] 1) Parameter grouping and dynamic codebook allocation

[0172] Input: Original Gaussian parameters (position, color SH coefficient, covariance rotation / scale, opacity)

[0173] Parameter grouping: The color group is split into DC components (1D) and SH coefficients (15D), with the SH coefficients further divided into low-frequency (orders 1-3) and high-frequency (orders 4-15). The covariance group is split into rotated quaternions (4D) and logarithmic scales (3D).

[0174] Information entropy calculation: Calculate the information entropy for each set of parameters:

[0175]

[0176] Parameter meaning:

[0177] x: Parameters to be compressed (such as color SH coefficients, covariance components, etc.).

[0178] p: The probability of a parameter value appearing in the dataset.

[0179] 2) Dynamic codebook allocation:

[0180]

[0181] Total codebook size (e.g., 32K). Size of the g-th codebook

[0182] Residual Quantization (RVQ) and Mixed Precision Training

[0183] For each set of parameters, initial quantization is performed using a low-bit codebook (4 bits, 16 centers):

[0184]

[0185] Residual calculation and secondary quantization:

[0186]

[0187] Where r (Residual) is an 8-bit codebook (256 centers).

[0188]

[0189] Core idea: During training, quantizers of different precisions are jointly optimized, and the soft and hard quantization weights are controlled by temperature annealing to gradually converge to the optimal quantization result.

[0190] Temperature annealing weighting formula:

[0191]

[0192] Error of hard quantization (direct rounding)

[0193] Error of soft quantization (preserving floating-point residuals)

[0194] T: Temperature parameter, with a high initial value (e.g., 1.0) that gradually decreases to near 0 (e.g., 0.1).

[0195] 3) Output:

[0196] Quantization parameters:

[0197] Codebook data:

[0198] The coarse quantization codebook C coarse preserves low-frequency features, while the residual codebook C residual compensates for high-frequency details.

[0199] 8. Enhanced dynamic pruning strategy

[0200] 1) Input: Gaussian parameters and their multi-view visibility records during training.

[0201] Multifactor energy calculation:

[0202]

[0203] Opacity;

[0204] : The distance from Gauss to the origin of the scene;

[0205] The number of times Gauss is visible in the training perspective.

[0206] α=0.6, β=0.3, γ=0.1 (weights adjustable)

[0207] 2) Soft pruning and recovery mechanism

[0208] Dynamic threshold adjustment:

[0209] The average energy of all current Gaussians. The standard deviation is denoted as .

[0210] Dormant flag: if Mark Gaussian i as hibernating (set) The parameters are retained but not involved in rendering. The dormant Gaussian does not participate in forward rendering but does participate in backpropagation updates.

[0211] Region Loss Monitoring: The scene is divided into a 16×16×16 voxel mesh, and the rendering loss L region of the dormant Gaussian within each voxel is calculated. If the rendering loss L region > η in M ​​consecutive iterations, the dormant Gaussian within that region is awakened, triggering the recovery mechanism. Default M=10, η=0.05 (adjustable).

[0212] Gaussian Recovery: Awakens the dormant Gaussian within the voxel, resets σi to its initial value, and increases its energy weight α to 0.8 (to prevent it from being clipped again).

[0213] 3) Output: Pruned Gaussian set: Only active (σi > 0) and restored Gaussians are retained.

[0214] Hibernation pool: Stores hibernation Gaussian parameters for later recovery.

[0215] The specific pruning and codebook update operations are shown in Figure 3.

[0216] 9. Index Compression and Encoding Optimization

[0217] 1) Morton code sorting and differential coding

[0218] Input: Quantized Gaussian indices (integer sequence).

[0219] Coordinate normalization and Morton code calculation:

[0220] Normalize the Gaussian center coordinates [x,y,z] to the integer range [0,2^16−1] and calculate the three-dimensional Morton code.

[0221] Index sorting: Reorder the index in ascending order according to Morton code to generate an ordered sequence {I1, I2, ..., IN}.

[0222] Difference calculation:

[0223]

[0224] 2) Entropy coding and compression

[0225] Huffman code table generation:

[0226] Statistically analyze the frequency distribution of δi and assign short codewords to high-frequency values ​​(e.g., δ≤5).

[0227] Binary compression:

[0228] The differential sequence is converted into a Huffman-coded bit stream and then packaged and stored in big-endian order.

[0229] 3) Output: Compressed data: Huffman coding table + differentially coded bit stream.

[0230] Compression ratio: Reduced from 4 bytes / ID in the original index to an average of 0.5 bytes / ID (compression ratio of 85%).

[0231] As can be seen from the above description, the beneficial effects of the technical solution of the present invention are as follows:

[0232] 1) Significantly reduce storage overhead and improve deployment efficiency

[0233] Results: The model size is compressed to 1 / 45 of the original 3DGS, breaking through the storage bottleneck of low-end devices.

[0234] Technical support:

[0235] Dynamic codebook allocation: The codebook capacity is allocated according to the parameter entropy value to reduce redundant codewords (e.g., the codebook for high-frequency SH coefficients is increased to 16K, while that for low-frequency codes is only 4K).

[0236] Residual Quantization (RVQ): Two-stage quantization preserves high-frequency details, improving PSNR by 0.2-0.3dB at the same bit rate.

[0237] Index compression optimization: Morton code sorting + differential Huffman coding, reducing index size by 85%.

[0238] 2) Improved rendering speed to meet real-time requirements.

[0239] Results: Rendering speed reaches 412 FPS (1080p resolution), which is 3 times faster than the original 3DGS (134 FPS).

[0240] Technical support:

[0241] Dynamic pruning: Pruning 70% of low-contribution Gaussians using the energy function reduces the computational cost of rasterization.

[0242] Hardware-friendly encoding: The indexes after sorting the Morton code are stored contiguously, which improves the GPU cache hit rate and increases the decoding speed by 40%.

[0243] 3) High-fidelity rendering quality with controllable loss of detail.

[0244] Results: PSNR decreased by only 0.07dB (27.42dB on the original 3DGS dataset on the Tanks & Temples dataset → 27.35dB of this invention), and high-frequency textures and edge sharpness were better than CompGS.

[0245] Technical support:

[0246] Residual quantization compensation: Secondary quantization of the high-frequency SH components of color reduces quantization error by 50%.

[0247] Soft pruning recovery mechanism: The probability of accidentally deleting key Gaussian nodes is reduced by 80%, and details are dynamically recovered through regional loss monitoring.

[0248] 4) Adapts to scene complexity and has strong generalization ability

[0249] Results: Maintains stable compression ratio and quality in both urban scenes (high geometric complexity) and indoor scenes (high material detail).

[0250] Technical support:

[0251] Dynamic codebook allocation: The codebook capacity is adaptively adjusted according to the parameter entropy, avoiding overfitting / underfitting caused by fixed allocation.

[0252] Multi-factor energy function: Integrates spatial density, view coverage and other indicators to adapt to the pruning needs of different scenarios.

[0253] 5) Optimization of training and inference efficiency

[0254] Results: Training time was reduced by 20%, and codebook convergence stability was improved.

[0255] Technical support:

[0256] Progressive quantization training: In the early stages, quantization is avoided to prevent interference with parameter convergence. In the later stages, the quantization intensity is gradually increased, reducing the number of codebook updates by 30%.

[0257] Hybrid precision codebook: By dynamically balancing precision and efficiency through soft selection weights, backpropagation speed is improved by 15%.

[0258] Example:

[0259] This embodiment illustrates a specific implementation of a real-time 3D Gaussian Splatting model compression system that combines residual vector quantization and dynamic pruning. Figure 4 is a flowchart of the project workflow in this embodiment of the invention.

[0260] In practice, this invention uses the kitchen scene from the Mip-NeRF 360 dataset for experimental verification.

[0261] Step A: Use SFM technology to generate a sparse point cloud from the kitchen scene image in Mip-NeRF 360, and then input it into the original 3DGS model for 3D modeling. The established 3D Gaussian scene is constructed from millions of Gaussian spheres. Each Gaussian sphere contains position coordinates, rotation quaternions, normal vectors, opacity, color, and up to 44 spherical harmonic function bands (SH1-SH44) to achieve viewpoint-dependent color information representation. The measured psnr=32.06, ssim=0.930, lpips=0.120, and storage size is 440MB.

[0262] Step B: The established 3D Gaussian scene is transferred to the 3D model compression system designed in this invention. The system compresses the 3D Gaussian scene through three modules, including vector quantization strategy, dynamic pruning strategy enhancement, and index compression and encoding optimization.

[0263] Module 1 Vector Quantization Strategy: This module employs hierarchical residual quantization and entropy-driven codebook allocation to achieve efficient compression. First, parameters are divided into three groups based on physical characteristics: low frequency (position / covariance), mid frequency (SH low-frequency components), and high frequency (SH high-frequency components). Codebook capacity is dynamically allocated based on information entropy (16K codebooks (12-bit index) are allocated to the high-frequency group). Error is reduced through two-stage residual quantization (RVQ): the first stage uses K-means to generate the basic codebook, and the second stage further quantizes the residuals (reducing the codebook capacity to 1 / 4). The final parameter recovery formula is X = Q1(X) + Q2(R). This strategy achieves a 10:1 compression ratio, PSNR loss ≤0.1dB, and supports FP16 / FP32 mixed-precision codebooks for low-end devices.

[0264] Module Two: Enhanced Dynamic Pruning Strategy. This module balances rendering efficiency and quality through energy function and spatial awareness restoration. The energy function combines density (weight 0.6), view coverage (0.3), and gradient magnitude (0.1), retaining the top 30% of high-energy Gaussian points, and the rest are processed using spatial hashing (0.1m). 3 (Voxel granularity) is stored in the hibernation pool. During real-time rendering, local image quality is monitored, and hibernation points are activated smoothly through neighbor interpolation, with a recovery latency of ≤5ms. Combined with GPU batch rasterization (8x8 pixels / thread block) and warp-level transparent pixel merging, the rendering frame rate is increased to over 1080p@400FPS, and the computational load is reduced by 22%.

[0265] Module 3 Index Compression and Encoding Optimization: This module reduces storage and transmission overhead through spatial indexing and entropy encoding. It employs 32-bit Morton code to encode the spatial location of Gaussian points (Z-shaped curve sorting), improving data locality and generating 128-byte aligned memory blocks, adapting to the GPU SIMD instruction set. Index differential encoding converts the differences between adjacent Morton codes into Huffman code streams; short differences (≤8) are represented by short codes, and long differences trigger block reassembly, resulting in a 70% reduction in index size.

[0266] Step C: This embodiment addresses the hardware bottleneck of low-end graphics cards (≤4GB VRAM, limited computing power) by achieving efficient deployment through hierarchical VRAM management, computational pipeline decomposition, and dynamic power consumption control. A hierarchical VRAM strategy is adopted, storing high-frequency parameters (location, SH low-frequency components) in the resident VRAM area (≤1.5GB) with FP16 precision, while low-frequency parameters (covariance matrix, SH high-frequency components) are stored in 0.5m... 3Spatial chunking is dynamically loaded, with only the currently visible 3×3 chunks (27 chunks) loaded via view frustum pruning and transmitted asynchronously (CUDA streaming achieves latency ≤3ms). The computational task is decomposed into a three-stage pipeline: the first-stage pipeline (50% CUDA Cores) handles Gaussian projection and sorting (8 points / thread, batch size 256); the second-stage pipeline (30% CUDA Cores) performs rasterization and blending (8x8 pixel blocks / thread blocks, warp-level atomic operations); and the third-stage pipeline (20% CUDA Cores) handles residual compensation and super-resolution reconstruction. For power consumption control, the GPU frequency is dynamically adjusted based on core temperature (full speed 1455MHz / 75W below 70℃, downclocked to 1083MHz / 45W above 85℃), and BC7 compressed textures are enabled to reduce bandwidth by 40%. At high temperatures, the number of active points per frame is limited to ≤30k. Verified results show that on an NVIDIA GTX 1050 Ti (4GB), 1080p@62FPS is achieved with 3.2GB of VRAM usage and a peak power consumption of 73W (78℃). On an AMD RX 560 platform, VRAM usage is 3.5GB with a frame rate of 58FPS, and the Intel Arc A380 achieves a frame rate of 72FPS (71℃). It supports rendering up to 100 million Gaussian points (compared to only 30 million using conventional methods), with CUDA core utilization reaching 90%. Under continuous load at 70℃ for 72 hours, there was no frequency throttling (error rate <0.1%). The compressed data shows psnr=31.86, ssim=0.921, lpips=0.129, and a storage size of only 18.9MB.

[0267] An application embodiment of the present invention provides a computer device, which includes a memory and a processor. The memory stores a computer program, and when the computer program is executed by the processor, the processor performs the steps of a 3D Gaussian sputtering compression method based on residual quantization and dynamic pruning.

[0268] An application embodiment of the present invention provides a computer-readable storage medium storing a computer program that, when executed by a processor, causes the processor to perform the steps of a 3D Gaussian sputtering compression method based on residual quantization and dynamic pruning.

[0269] An application embodiment of the present invention provides an information data processing terminal, which includes a 3D Gaussian sputtering compression system based on residual quantization and dynamic pruning.

[0270] This invention can be widely applied to the following fields and products: In real-time 3D modeling and rendering engines (such as Unreal Engine and Unity's 3D Gaussian splash plugin), through dynamic codebook allocation and residual quantization technology, the storage volume of tens of millions of Gaussian parameters is compressed from 12.4GB to 3.8GB, achieving real-time rendering at 55FPS, supporting smooth loading of large virtual scenes for VR / AR headsets (such as MetaQuest Pro); In autonomous driving LiDAR point cloud processing systems (such as the embedded processor of Velodyne VLS-128), by combining dynamic pruning and mixed precision quantization, single-frame point cloud data is compressed from 50MB to 8.2MB, with a decoding latency of less than 9ms, enabling L4 autonomous vehicles (such as Waymo's fifth-generation system) to perceive obstacles in real time under 5G networks; In edge AI inference devices (such as DJI Matrice 300)... In the airborne target detection module of RTK drones, a hierarchical vector quantization strategy is adopted to compress the YOLOv5 model size from 7.1MB to 1.2MB, increasing the inference speed to 38FPS, enabling human and vehicle recognition in 4K video streams; in medical imaging cloud platforms (such as United Imaging Healthcare uCloud Precision Diagnosis System), through ROI region adaptive compression and residual secondary quantization, the MRI image compression ratio is increased from 10:1 to 15:1, and the transmission time is shortened from 3.2s to 1.8s, supporting primary hospitals to access 45dB high-fidelity images from tertiary hospitals in real time; in industrial digital twin systems (such as the Siemens MindSphere platform), based on entropy-driven codebook allocation technology, the point cloud model of production line equipment is compressed by 60%, enabling the full loading of a factory model of 2000 devices on a 16GB memory workstation, facilitating real-time fault prediction. These product-level applications validate the universality of this invention in the field of high-dimensional data compression, reconstructing the technological benchmark for 3D graphics, autonomous driving, edge intelligence, and medical imaging industries with "lower storage, faster computation, and less quality loss."

[0271] As shown in Figure 5, in the experiments, we used three commonly used parameters—PSNR, L-PIPS, and SSIM—as metrics to measure the quality of the generated images. The model's storage size is represented by `size`, with units in MB. To better evaluate the performance of our method, we also compared it with several compression methods similar to our work. 3DGS was used as the baseline, and the methods in the middle section represent the mainstream compression methods currently designed for 3DGS. Red represents the best method, followed by orange, and then yellow. The results show that our method, while maintaining a smaller model size, can still achieve or even surpass the performance of existing methods in terms of reconstruction quality. To better highlight the performance improvement of the model, this invention used the same parameter configuration as the original 3DGS method in the experiments. All experiments were conducted on an NVIDIA 3090 GPU.

[0272] As shown in Figure 6, the Gaussian scene with high storage requirements is greatly reduced after processing by this invention without compromising fidelity.

[0273] It should be noted that embodiments of the present invention can be implemented in hardware, software, or a combination of both. The hardware portion can be implemented using dedicated logic; the software portion can be stored in memory and executed by a suitable instruction execution system, such as a microprocessor or dedicated-design hardware. Those skilled in the art will understand that the above-described devices and methods can be implemented using computer-executable instructions and / or included in processor control code, for example, such code provided on a carrier medium such as a disk, CD, or DVD-ROM, a programmable memory such as read-only memory (firmware), or a data carrier such as an optical or electronic signal carrier. The devices and modules of the present invention can be implemented by hardware circuitry such as very large-scale integrated circuits or gate arrays, semiconductors such as logic chips, transistors, or programmable hardware devices such as field-programmable gate arrays, programmable logic devices, etc., or by software executed by various types of processors, or by a combination of the above-described hardware circuitry and software, such as firmware.

[0274] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any modifications, equivalent substitutions, and improvements made by those skilled in the art within the scope of the technology disclosed in the present invention, and within the spirit and principles of the present invention, should be covered within the scope of protection of the present invention.

Claims

1. A 3D Gaussian sputtering compression method based on residual quantization and dynamic pruning, characterized in that, include: S1: Residual quantization vector quantization, which groups the 3D Gaussian parameters and dynamically allocates the codebook capacity, reducing data storage usage through stepwise quantization; S2: Enhanced dynamic pruning strategy, which adaptively prunes redundant Gaussian points based on energy function calculation and visibility analysis. S3: Index compression and encoding optimization, using Morton code sorting, differential encoding, and entropy encoding to improve data storage efficiency; S1 includes: grouping Gaussian parameters, including color and covariance, where color includes DC component + SH coefficient, and covariance includes rotated quaternion + logarithmic scale; calculating the information entropy of each group of parameters and allocating the quantization codebook capacity according to the entropy ratio; using progressive residual quantization (RVQ), first performing low-bit-rate coarse quantization, and then performing higher-precision secondary quantization on the residual part; during training, dynamically adjusting the weights of soft quantization and hard quantization in conjunction with a temperature annealing mechanism to make the final quantization result tend to be optimal; S2 includes: calculating the energy of each Gaussian, including opacity, distance, and visibility factors, and constructing an energy function; setting a dynamic threshold, adjusting the pruning standard based on the mean and standard deviation of Gaussian energy, and putting low-contribution Gaussians into dormancy; using a region loss monitoring method to statistically analyze the rendering loss within the voxel grid, and if the loss exceeds the set threshold for M consecutive iterations, reactivating the dormant Gaussian.

2. The 3D Gaussian sputtering compression method as described in claim 1, characterized in that, S3 includes: normalizing the Gaussian center coordinates (x, y, z) using Morton code and calculating the three-dimensional Morton code; sorting the index according to the Morton code to improve the locality of data access; and using differential coding to store incremental data between adjacent indices to reduce storage redundancy.

3. The 3D Gaussian sputtering compression method as described in claim 1, characterized in that, S3 also includes: entropy encoding of the differentially encoded index data, optimizing the storage structure using Huffman coding; statistical analysis of the distribution of index increments, assigning shorter codewords to high-frequency values ​​to reduce storage usage; and storing the Huffman-coded table and bitstream in binary compression format, reducing the index storage requirement from 4 bytes / ID to 0.5 bytes / ID.

4. The 3D Gaussian sputtering compression method as described in claim 1, characterized in that, Also includes: By combining multi-view information of Gaussian parameters, the pruning strategy is optimized so that Gaussian points have a higher survival probability in key views, thus ensuring rendering quality. A multi-level index structure is adopted, which enables the rapid retrieval of regions that need to be activated when dynamically restoring dormant Gaussian points, thereby improving computational efficiency. By jointly optimizing residual quantization vector quantization, enhancing dynamic pruning strategies, and optimizing index compression and encoding, the overall compression ratio is improved, while ensuring a balance between rendering quality and computational efficiency.

5. A 3D Gaussian sputtering compression system based on residual quantization and dynamic pruning, implementing the 3D Gaussian sputtering compression method based on residual quantization and dynamic pruning as described in any one of claims 1 to 4, characterized in that, include: The quantization module is used for residual quantization and vector quantization. The strategy enhancement module is used to enhance dynamic pruning strategies. The compression and optimization module is used for index compression and encoding optimization.

6. A computer device comprising a memory and a processor, the memory storing a computer program, which, when executed by the processor, causes the processor to perform the steps of the 3D Gaussian sputtering compression method based on residual quantization and dynamic pruning as described in any one of claims 1 to 4.

7. A computer-readable storage medium storing a computer program, which, when executed by a processor, causes the processor to perform the steps of the 3D Gaussian sputtering compression method based on residual quantization and dynamic pruning as described in any one of claims 1 to 4.

8. An information data processing terminal, comprising the 3D Gaussian sputtering compression system based on residual quantization and dynamic pruning as described in claim 5.

Images