Modern scientific simulations and instruments produce volumetric data at rates that far outpace the growth of storage and network capacity. Large-scale astrophysics, climate science, and turbulent combustion simulations routinely generate extreme-scale data, while the cost of storing and moving such data continues to grow. For this reason, data archival and transmission have become major bottlenecks in scientific workflows, limiting both the scale of simulations that can be preserved and the speed at which results can be shared and analyzed.

As a viable solution, lossy compression addresses this challenge by significantly reducing data size while preserving essential features for visualization and analysis. Conventional error-bounded lossy compressors, such as ZFP [1], TTHRESH [2], and SZ3 [3], rely on predefined mathematical transforms or predictors. While effective at moderate compression ratios (CRs), say a few hundred, these methods suffer severe distortion at high CRs (over 1,000). Besides these general-purpose compressors, non-neural learning-based solutions, such as hierarchical vector quantization [4] and sparse dictionary learning [5]–[7], learn codebooks or dictionaries directly from the data, which have mostly been integrated into real-time compression-domain rendering pipelines.

Implicit neural representations (INRs) [8] treat compression as function approximation and support random access. They yield high CRs while preserving good data quality. However, INR-based approaches have significant drawbacks: fully connected INRs [8]–[10] may require several hours of training time per volume; grid-based INRs [11]–[13] accelerate training but achieve lower CRs; and a single trained model corresponds to only one specific CR.

Autoencoder (AE) methods, such as AE-SZ [14] and IDLat [15], map volume blocks to compact latent representations, yet they exhibit notable limitations as compression tools. First, their CRs do not demonstrate significant advantages over state-of-the-art conventional compressors [2], [3]. Second, these methods are typically trained on small-scale datasets (e.g., a few volume blocks sampled from a single time-varying volumetric dataset). While they can generalize to other timesteps within the same dataset, cross-dataset generalization remains an open challenge. Third, as with INR methods, the CRs of AEs are determined by fixed latent-space dimensions, thereby requiring different model architectures for different target rates. Due to these limitations, prior research has predominantly leveraged AEs as visual analysis tools [15], [16] rather than as competitive compression tools.

To address these challenges, we rethink the application of AEs to volumetric data compression and propose an AE-based framework, named EVOLVE (Efficient Learned VOLume Compression with Variable-Rate Encoding). Unlike methods that incorporate compression-domain rendering, EVOLVE targets high CRs for offline purposes, where the full volume is reconstructed before visualization and analysis. Under this setting, EVOLVE aims to encode and decode various volumes with a single shared model (see Section 3.5). We introduce three key innovations to overcome the existing limitations. First, to achieve higher CRs than conventional compressors at equivalent reconstruction quality, we incorporate advanced context-aware entropy modeling that combines spatial-wise [17]–[19] and channel-wise context [20], fusing multi-source information to estimate latent-variable distributions accurately. Second, to enable cross-dataset generalization, we construct a large-scale training database comprising thousands of volumes spanning diverse scientific simulation domains, allowing the model to learn transferable feature representations and, after being optimized on sufficiently representative volumes from a given domain, it can support compress unseen data without per-volume optimization. Third, to support flexible CRs with a single model, we adopt a learnable gain mechanism that enables continuous rate variation, coupled with a three-stage training strategy to ensure consistent performance across the entire rate-distortion spectrum.

We evaluate EVOLVE on multiple scientific simulation datasets against conventional compressors, INR methods, and prior AE approaches. At equivalent reconstruction quality, EVOLVE attains substantially higher CRs than both conventional and AE-based methods (see Figure [fig:teaser]), while compressing orders of magnitude faster than INR methods on encoding speed. Moreover, a single EVOLVE model spans a continuous rate-distortion range, eliminating the need to train a separate model for each target CR, and generalizes well to volumes unseen during training. That said, EVOLVE is validated primarily on curated scientific simulation data; extending it to other domains, such as medical or microscopy volumes, would require retraining on representative data.

In summary, this paper makes the following contributions.

• We propose EVOLVE, an AE-based volumetric data compression framework that achieves high compression efficiency through advanced context-aware entropy modeling and significantly outperforms existing methods at equivalent reconstruction quality, while supporting continuous single-model variable-rate compression without requiring multiple models per setting.

• We construct the first large-scale volume database spanning diverse scientific domains, enabling a single trained compression model to generalize to unseen volumes from the covered scientific simulation domains without per-volume optimization.

• Extensive experiments show that EVOLVE achieves state-of-the-art compression performance across multiple datasets while demonstrating strong generalization and practical efficiency for unseen simulation data.

1 Related Work↩︎

1.1 Lossy Volumetric Data Compression↩︎

Lossy compression has been critical for managing the massive storage requirements and addressing I/O challenges posed by large-scale scientific simulations. Many schemes embed compressed representations into the rendering pipeline, decoding only the portion needed per frame on demand. Treib et al. [21] developed a GPU-decodable wavelet codec for terascale turbulence, Nystad et al. [22] introduced the fixed-rate block-local texture format ASTC with constant-time random access, and Schneider and Westermann [4] proposed a hierarchical vector-quantization scheme. Gobbetti et al. [5] developed COVRA, which models octree data blocks at multiple resolutions as sparse combinations of learned dictionary atoms, and Marton et al. [6] and Díaz et al. [7] later scaled this direction to massive time-varying data with out-of-core GPU streaming of variable-rate sparse codes. Among them, works including [4]–[7] are considered learning-based solutions that optimize dictionaries and sparse codes from the data. Such methods prioritize random access and decoding throughput at render time. For more details about compression-domain volume rendering, we refer readers to the surveys [23], [24]. A complementary line of work targets offline storage and transmission, decompressing the full volume before any visualization or analysis. Lindstrom [1] developed ZFP, which applies customized block-level transforms with fast I/O access; Liang et al. [3] developed SZ3, an error-bounded framework built on an improved Lorenzo predictor; and Ballester-Ripoll et al. [2] proposed TTHRESH, using tensor decomposition via higher-order SVD. Yan et al. [25] further proposed TopoSZ to preserve topological features under user-specified error bounds. Like these methods, EVOLVE is designed for offline compression, reconstructing the full volume before use rather than for transient render-time decoding (for more discussion, refer to Section 3.5).

1.2 Deep Learning for Volume Visualization↩︎

Deep learning solutions [16], [26]–[31] have been increasingly applied to volume generation, scene representation and data compression [32]. Since SIREN [8] introduced periodic activation functions to capture high-frequency details, INRs have emerged as a promising paradigm for representing data as continuous functions parameterized by neural networks. NeurComp [9] was the first to apply SIREN-based architectures with residual connections to volumetric scalar field compression, utilizing network weight quantization to achieve high CRs. To accelerate training and inference, grid-based approaches replace a large part of the fully connected layers with trainable feature grids (e.g., the multiresolution hash encoding of Instant-NGP [33]) that are queried by a lightweight multilayer perceptron (MLP), trading larger model sizes for orders-of-magnitude faster optimization and rendering. fV-SRN [11] uses a coarse grid of learnable latent features, together with a small MLP, to enable interactive volume rendering via custom CUDA TensorCore kernels. APMGSRN [13] improves reconstruction quality through multiple spatially adaptive feature grids that dynamically allocate network parameters to high-error regions. For time-varying data, KD-INR [10] employs knowledge distillation to sequentially compress individual timesteps into a single coherent model, while ECNR [34] utilizes a Laplacian pyramid for multiscale spatiotemporal decomposition with parallel MLPs. Other examples include STSR-INR [35], Meta-INR [36], MC-INR [37], and Lossless-INR [38]. F-Hash [39] further extends multiresolution hash encoding to the spatiotemporal domain through a feature-based tesseract encoding, accelerating convergence on time-varying volumes. However, INR methods require per-volume training, limiting their practical applicability for general-purpose compression.

AE-based methods offer an alternative by learning generalizable latent representations. Deep Fluids [40] employs a generative AE to learn compact latent representations of fluid flows from parameterized simulations. FlowNet [16] uses a sparse stacked AE to learn implicit feature descriptors from streamlines or stream surfaces for clustering and selection. AE-SZ [14] integrates a convolutional AE as a predictor within the SZ framework to improve prediction accuracy. IDLat [15] generates latent representations guided by spatial importance maps, ensuring higher reconstruction quality in user-specified regions. While these methods demonstrate the potential of AEs for scientific data, they are typically trained on small-scale datasets from single simulations and achieve CRs around a few hundred at comparable quality, which does not significantly outperform state-of-the-art conventional compressors. Our EVOLVE addresses these limitations by training on a database with thousands of volumes to achieve cross-dataset generalization, while substantially surpassing both prior AE methods and conventional compressors in CR at equivalent reconstruction quality.

1.3 Learned Neural Data Compression↩︎

End-to-end learned compression has achieved remarkable success in image coding, surpassing traditional codecs such as JPEG [41] in rate-distortion performance. Unlike conventional approaches that rely on handcrafted transforms and entropy coders, learned methods jointly optimize the encoder, decoder, and entropy model through gradient descent, enabling the network to discover data-adaptive representations. Ballé et al. [42], [43] established the foundational variational AE framework with nonlinear transforms and introduced the scale hyperprior to capture spatial dependencies in latent representations. Subsequent work focused on improving entropy modeling through context models. Minnen et al. [17] combined the hyperprior with autoregressive context modeling to outperform traditional codecs, and subsequent research [19], [20], [44] further improved the accuracy of entropy estimation and decoding efficiency. For variable-rate compression, Cui et al. [45] proposed asymmetric gain units that rescale latent magnitudes, enabling continuous bitrate adjustment within a single model. These techniques have been extended to video compression [46], [47] and Gaussian splatting [48]–[51], demonstrating the broad applicability of learned entropy modeling. In this work, we extend 2D learned compression techniques to 3D volumetric data by adapting context models for spatial volumes and training on a large-scale volume database to achieve generalization across the diverse scientific simulation domains it covers.

2 EVOLVE↩︎

This section presents the three core contributions of EVOLVE. First, we describe how we collect and curate our high-quality database of thousands of volumes for training in Section 2.1. Second, in Section 2.2, we provide an ablation-based roadmap that progressively upgrades an initially underperforming vanilla AE into EVOLVE, ultimately outperforming existing state-of-the-art conventional compressors. Third, we describe how we achieve variable-rate encoding in EVOLVE, enabling multiple CRs within a single model for more flexible deployment, as detailed in Section 2.3.

2.1 Database Curation↩︎

Training an effective learned volume compression model requires a large-scale, diverse, and high-quality database: models trained on narrow data distributions tend to overfit dataset-specific spatial statistics rather than learn transferable representations. Therefore, we curate our database by collecting time-varying scientific simulation data from multiple established repositories, including the Open SciVis Datasets [52], IEEE SciVis Contest archives [53], ETH Zürich visualization datasets [54], and Well [55], as well as our in-house simulation data. The resulting database comprises 21 datasets totaling 9,921 volumes across various scientific domains, before further filtering. This breadth ensures that the training data covers a wide range of physical quantities and spatial structures. Its full composition is provided in Appendix 5.

Time-varying simulations often exhibit significant redundancy across consecutive frames, which can be suboptimal for training. For example, five-jet contains 2,000 timesteps, yet the dynamics evolve slowly, making adjacent frames nearly indistinguishable. Directly using all 9,921 volumes can lead the model to memorize over-represented local patterns, reducing training efficiency and harming out-of-distribution performance, as observed in prior large-scale database curation studies [56], [57]. To improve the quality and diversity of our database, we design a curation process to identify and remove redundant volumes before training. Specifically, we adopt pHash [58], a perceptual hash-based strategy, to quantify structural similarity and identify near-duplicate samples. Specifically, we apply a 3D discrete cosine transform (DCT) to each volume, binarize the low-frequency DCT coefficients into a perceptual hash, and measure pairwise similarity using the Hamming distance between hashes. Inspired by nearest neighbor search [59], [60], we define the nearest-neighbor similarity (NNS) for each volume as the similarity to its closest neighbor and use the 95th-percentile of NNS within each dataset as a diversity metric. In our corpus, datasets such as five-jet and supercurrent initially exhibit very high redundancy, with the 95th-percentile NNS exceeding 0.95, indicating that many frames are near-duplicates. We perform deduplication for datasets whose 95th-percentile NNS exceeds 0.85 by clustering highly similar volumes with a union–find algorithm and retaining one representative per cluster. We repeat this filtering until the dataset-level NNS falls below 0.85. After each filtering iteration, we further validate the results with a visual inspection step that operates only on the clusters identified by deduplication: we render each retained representative side-by-side with its flagged near-duplicates using random transfer functions. Since the goal is to detect structural near-identity between candidate duplicates rather than to produce perceptually meaningful visualizations, randomly sampled transfer functions are sufficient. After filtering, the final training set contains 6,376 volumes with substantially improved diversity in data distribution.

Train/validation/test split. All 6,376 curated volumes are used exclusively for training, while design decisions are made on a small validation subset of the training volumes, with its own 95%/5% train/validation split (see Section 2.2). For evaluation, we deliberately avoid splitting along the temporal axis, as holding out intermediate timesteps of highly correlated sequences would inflate test performance. All test volumes (see Table 1) are drawn from unseen simulations or variables and are disjoint from the 9,921 collected volumes.

2.2 Ablation-Based Roadmap↩︎

In this section, we describe the design process of EVOLVE through a systematic architectural ablation roadmap. We conduct this ablation study using a small subset of the 6,376 training database to identify effective design choices. Specifically, for each dataset listed in Table 4, we randomly sample 5% of the selected volumes, resulting in a subset of 319 volumes. We then use 95% of them (303 volumes) for training and the remaining 5% (16 volumes) for validation. Experimenting first on such a small subset of volumes allows us to compare different architectural variants while avoiding the optimization noise introduced by long training cycles on the large volume database.

We start with a vanilla convolutional AE that has strided convolution layers for downsampling and deconvolution layers for upsampling, with generalized divisive normalization (GDN) [61] as the normalizing function, following common design choices in prior AE-based compressors [14], [15]. To avoid excessive memory consumption, we adopt the same block-based processing strategy [26], [62] in which the network operates on fixed-size blocks cropped from the target volume. We set the block resolution to 64\(\times\)​64\(\times\)​64 as our starting point. During inference, the decoded blocks are merged using a weighted blending scheme, which leverages spatial overlap to avoid boundary discontinuities. The vanilla AE is optimized using a mean squared error (MSE) loss computed between the ground truth (GT) and the decoded volumes. We then progressively modernize each component of this vanilla AE toward our final EVOLVE model, as summarized in Figure 1.

2.2.1 Training Techniques↩︎

All model variants in the roadmap are trained for 500 epochs on a small subset of volumes, using a learning rate of 0.0001 and a batch size of 16. Because voxel statistics vary significantly across scientific domains, direct optimization on a large database suffers from instability and slow convergence, so we adopt several modern training techniques. In particular, we employ a linear warmup [63] during the first 20 epochs to stabilize early-stage optimization under heterogeneous data distributions, and use the AdamW optimizer [64] for its robustness to scale variation and improved generalization through decoupled weight decay. In addition, common data augmentation techniques described in [65], such as random cropping, flipping, and rotation, are applied to enhance robustness to spatial variability and improve generalization across diverse volumetric structures.

2.2.2 Macro Design↩︎

We denote the input volume as \(\boldsymbol{x}\in\mathbb{R}^{H\times W\times D}\). The encoder of the vanilla AE performs a non-linear analysis transform \(g_a(\cdot)\) to produce a latent representation \(\boldsymbol{y}\). The decoder then applies a non-linear synthesis transform \(g_s(\cdot)\) to generate the reconstructed volume \(\hat{\boldsymbol{x}}\). Although the latent representation \(\boldsymbol{y}\) is typically more compact than the original volume \(\boldsymbol{x}\), it still contains substantial redundancy that can be further exploited for compression. Motivated by this, we introduce a series of macro-level design choices to improve compression performance.

Factorized entropy model. The most straightforward way to compress the latent representation \(\boldsymbol{y}\) is quantization, which can be expressed as \(\hat{\boldsymbol{y}} = Q(\boldsymbol{y})\), where \(Q(\cdot)\) denotes the quantization operator. If a probability model \(p_{\hat{\boldsymbol{y}}}(\hat{\boldsymbol{y}})\) is given, entropy coding techniques, such as arithmetic coding [66], can then be used to encode the quantized codes into a compact bitstream losslessly. In practice, under a factorized entropy model, \(p_{\hat{\boldsymbol{y}}}(\hat{\boldsymbol{y}})\) is represented by learnable channel-wise Gaussian parameters \((\boldsymbol{\mu}, \boldsymbol{\sigma})\) as illustrated in Figure 2 (a) and optimized during training. Since arithmetic coding is near-optimal, the entropy of \(\hat{\boldsymbol{y}}\) provides an accurate estimate of the coding rate. Consequently, we can formulate a rate-distortion loss \[\mathcal{L}_{RD} = \mathcal{R}(\hat{\boldsymbol{y}}) + \lambda \, D(\boldsymbol{x}, \hat{\boldsymbol{x}}), \label{eqn:factorized}\tag{1}\] where \(\mathcal{R}(\hat{\boldsymbol{y}})=\mathbb{E}\!\left[-\log_2 p_{\hat{\boldsymbol{y}}}(\hat{\boldsymbol{y}})\right]\) is the rate term that indicates the average number of bits used when saving \(\hat{\boldsymbol{y}}\) as bitstreams. \(D(\cdot)\) is the distortion term that is computed using the MSE loss between the GT and reconstructed data. \(\lambda\) is a Lagrange multiplier, a hyperparameter that controls the tradeoff between reconstruction quality and CR, and is set to 300 in our roadmap experiment. Note that the quantization operation is not differentiable. Therefore, we approximate quantized latent \(\hat{\boldsymbol{y}}\) by adding a uniform noise \(\mathcal{U}\!\left(-\tfrac{1}{2}, \tfrac{1}{2}\right)\) to the extracted \(\boldsymbol{y}\) during training. As shown in Figure 1, the factorized entropy model improves the CR, but leads to a degradation in reconstruction quality due to the introduction of the additional rate term \(\mathcal{R}(\hat{\boldsymbol{y}})\) in Equation 1 .

Hyperprior entropy model. In a factorized entropy model, latent elements within the same channel are assumed to follow a shared distribution across spatial positions, ignoring spatially varying statistics. In contrast, the hyperprior entropy model [42] introduces additional side information to more accurately estimate the probability of latent elements at different spatial locations, as shown in Figure 2 (b). Prior work, such as IDLat [15], falls into this category by adopting a hyperprior entropy model to improve CR. In particular, as illustrated in Figure 3 (a), the hyperprior entropy model introduces an additional hyper-latent \(\boldsymbol{z}\) extracted from \(\boldsymbol{y}\) via a hyper-analysis transform \(h_a\). The quantized hyper-latent \(\hat{\boldsymbol{z}}\) is entropy coded and transmitted as side information. By performing a hyper-synthesis transform \(h_s\), the decoded hyperprior \(\boldsymbol{\Psi}\) is used to condition the probability model of \(\hat{\boldsymbol{y}}\), resulting in spatially varying probability modeling. Similar to \(\hat{\boldsymbol{y}}\), the quantized hyper-latent \(\hat{\boldsymbol{z}}\) is also entropy coded and saved as bitstreams after encoding. Accordingly, an additional rate term \(\mathcal{R}(\hat{\boldsymbol{z}})\) is introduced into Equation 1 to optimize the bit cost associated with this part. The hyperprior entropy model improves the CR from 71.94\(\times\) of the factorized entropy model to 644.0\(\times\), with a slight improvement in reconstruction quality.

GDN \(\rightarrow\) residual block. We replace the GDN [61] functions used in many AE-based compressors, such as AE-SZ [14] and IDLat [15], with residual blocks [67]. GDN was initially designed to provide local normalization together with a point-wise nonlinearity. However, we empirically observe that with a large number of model parameters, incorporating multiple GDNs slows convergence, whereas residual blocks with skip connections facilitate stronger gradient flow and greater nonlinear expressiveness during training. Therefore, we replace GDN layers with residual blocks in our architecture. This substitution leads to a marked improvement in reconstruction quality and CR, though computational cost increases due to the added residual layers.

Context model. IDLat [15] adopted the hyperprior entropy model to achieve better compression performance than the factorized entropy model by enabling spatially varying probability modeling. However, the hyperprior model still assumes independence among latent elements given the side information and thus fails to fully exploit local dependencies between neighboring latent variables. In volumetric data, voxel values at nearby locations are often very close and highly correlated, indicating substantial local redundancy that can be removed to achieve more effective compression.

To respond, we propose to design a context model [19], [20], [47]–[50] that explicitly captures such local dependencies in the latent space. As illustrated in Figure 2 (c), we design our context model with two components: 3D checkerboard spatial context and channel context. The 3D checkerboard spatial context partitions the latent grid into anchor and non-anchor positions and predicts the probability distributions of non-anchor elements conditioned on already decoded anchor elements. This design enables local spatial dependency modeling while maintaining efficient parallel decoding. In addition to spatial dependencies, the context model also captures inter-channel correlations through a channel-context architecture that slices the latent into different channel groups and models them progressively, conditioning each group on previously decoded ones, as illustrated in Figure 2 (d). By jointly leveraging masked spatial and channel context, the proposed architecture enables more accurate probability estimation by conditioning on neighboring decoded information, thereby achieving better compression performance.

The architecture of the context model is illustrated in Figure 3 (b). When decoding the \(k\)-th channel group, the context module receives three types of conditioning information: the hyperprior \(\boldsymbol{\Psi}\), previously decoded channel groups \(\hat{\boldsymbol{y}}^{<k}\), and spatial anchor elements from the current channel group. The spatial anchor elements are either a zero vector for decoding anchor positions or the decoded anchors \(\hat{\boldsymbol{y}}_{\text{anc}}^{k}\) for decoding non-anchor positions. The spatial context feature \(\boldsymbol{\Phi}_{\text{sp}}^{k}\) is extracted by \(g_{\text{sp}}^{k}\), which is a single-layer masked convolution. The channel context feature \(\boldsymbol{\Phi}_{\text{ch}}^{k}\) is extracted by \(g_{\text{ch}}^{k}\), which consists of two depthwise convolution (DWConv) blocks followed by a 1\(\times\)​1 convolution. Since the dimensionality of \(\hat{\boldsymbol{y}}^{<k}\) varies with \(k\), separate context transforms \(g_{\text{sp}}^{k}\) and \(g_{\text{ch}}^{k}\) are employed for different channel groups. We adopt DWConv blocks to reduce computational cost, while the final 1\(\times\)​1 convolution enables effective channel-level feature fusion. Finally, the hyperprior, spatial context, and channel context features are then concatenated and fed into a lightweight aggregation network to estimate the Gaussian distribution parameters \((\boldsymbol{\mu}, \boldsymbol{\sigma})\) for entropy coding.

Our context model plays a critical role in improving compression performance and distinguishes EVOLVE from prior AE-based volume compression methods [14], [15]. While incorporating context modeling inevitably increases encoding and decoding latency due to its autoregressive nature, this design enables substantial improvements in CR while preserving reconstruction quality (see Figure 1), making it a key component of our framework.

2.2.3 Micro Design↩︎

Non-uniform channel allocation. Prior work [15] typically assigns the same number of channels to all network stages (i.e., \(C_1=C_2=C_3\) in Figure 3 (a)). In contrast, we observe that allocating more channels to deeper layers—where spatial resolution is progressively reduced—significantly improves reconstruction quality. Increasing channel width in deeper layers enhances the network’s capacity to model complex, high-level features in a more compact representation space, leading to more faithful reconstructions. To control computational cost, we reduce the channel width in shallow layers, where spatial resolution is higher, yielding larger savings in computation overhead. As shown in Figure 1, this design improves both CR and reconstruction quality.

PConv in residual blocks. We replace standard convolutions with advanced partial convolutions (PConv) [68] in the original residual blocks. PConv applies a parametric filter only to a few input channels, leaving the rest untouched. This substitution significantly reduces computational complexity without sacrificing much of the representation capacity, leading to faster encoding and decoding.

Non-uniform slicing in latent channels. In the channel-context architecture, a common practice [20] is to uniformly split latent channels into multiple groups. However, transform-based compression algorithms, such as TTHRESH [2], demonstrate that coefficients derived from high-dimensional data are not equally important and achieve competitive compression by truncating the long tail of minor coefficients. Inspired by this, we split \(\hat{\boldsymbol{y}}\) into uneven groups along the channel dimension. Since a network with comparable capacity models each group, this allocation implies that smaller groups benefit from denser parametric representation. This treatment effectively encourages the framework to learn fine-grained dependencies among critical components while efficiently handling redundant components with coarse-grained modeling. Consequently, it also allows us to minimize the total number of channel groups required without compromising reconstruction quality, thereby improving both compression efficiency and processing speed.

Attention block. Attention mechanisms [69] have demonstrated strong performance in large-scale models, and we also explore incorporating attention blocks into our architecture. While attention provides a modest improvement in reconstruction quality, it introduces a disproportionate increase in computational cost. As the marginal quality gain does not justify the added complexity, this modification is not adopted in the final model, as indicated by the hatched bar in Figure 1.

2.2.4 Block Size↩︎

All preceding experiments use a 64\(\times\)​64\(\times\)​64 block size for training. We conclude the roadmap by examining the effect of block size on compression performance. Smaller blocks require more patches to cover the full volume, leading to redundant boundary regions and limited receptive fields, which degrade both CR and reconstruction quality. Increasing the block size to 128\(\times\)​128\(\times\)​128 allows the model to capture longer-range spatial dependencies within a single forward pass. This final adjustment yields the complete EVOLVE model, which achieves the best performance across all metrics. However, increasing the block size substantially elevates both training and inference memory consumption due to the cubic growth of feature map resolution and intermediate activations. Given our current computational resources, we restrict the maximum block size to 128\(\times\)​128\(\times\)​128, providing a favorable tradeoff between compression performance and training cost.

2.3 Variable-Rate Encoding↩︎

A key limitation of existing deep-learning-based volume compressors [9], [13], [15] is that each trained model is tied to a single fixed CR. Supporting different rate-distortion tradeoffs, therefore, requires training, storing, and switching among multiple models, which is cumbersome in practical scientific workflows. To address this limitation, EVOLVE incorporates a learnable gain mechanism that enables a single model to span a continuous range of CRs during inference, without retraining or maintaining multiple models.

Gain-based quantization regulation. The core idea is to modulate the quantization bin size via a learnable gain vector \(\boldsymbol{\gamma} = [\gamma_0, \gamma_1, \ldots, \gamma_{A-1}]\), where each \(\gamma_i\) is initialized with a substantially different magnitude to cover a wide range of CRs before optimization, and \(A\) denotes the number of discrete quality levels. During compression at quality level \(i\), the latent representation \(\boldsymbol{y}\) is scaled by the corresponding gain \(\gamma_i\) prior to quantization and rescaled by its inverse afterward \[\hat{\boldsymbol{y}} = Q(\boldsymbol{y} \cdot \gamma_i) / \gamma_i, \label{eq:gain}\tag{2}\] where \(Q(\cdot)\) denotes the quantization operator. A large \(\gamma_i\) amplifies the latent values, equivalent to a smaller quantization bin size, resulting in a lower CR and better preservation of fine details. Conversely, a small \(\gamma_i\) increases the effective bin size, leading to coarser quantization and higher CR. Following [45], we define a set of rate-distortion tradeoff parameters \(\boldsymbol{\lambda} = [\lambda_0, \lambda_1, \ldots, \lambda_{A-1}]\) in one-to-one correspondence with the gain vector \(\boldsymbol{\gamma}\) during optimization. Before training starts, the gain values in \(\boldsymbol{\gamma}\) are initialized as \(\sqrt{\boldsymbol{\lambda}/\lambda_0}\) following [70]. After the model is sufficiently trained across the discrete quality levels, continuous variable-rate encoding can be achieved at inference time by interpolating between adjacent \(\boldsymbol{\gamma}\) values, enabling a single EVOLVE model to support a continuous range of CRs.

Three-stage training strategy. Training a variable-rate model end-to-end is challenging because the gain values interact with all other network weights, potentially destabilizing the optimization. To ensure stable convergence across the full range of quality levels, we adopt a three-stage training strategy. (1) In the first stage, the model is trained at a single, fixed highest quality level while the gain parameters are kept frozen. This stage allows the encoder, decoder, and entropy model to converge to a strong baseline without being affected by rate variation. (2) In the second stage, the gain parameters are unfrozen. The model is trained jointly across all \(A\) quality levels: at each iteration, a quality level \(i\) is selected by deterministically cycling through the levels, and the corresponding \(\lambda_i\) replaces \(\lambda\) in Equation 1 , with the network weights and gain parameters optimized simultaneously. (3) In the third stage, the model is further finetuned by replacing the uniform-noise quantization approximation with the straight-through estimator (STE) [71], ensuring that the learned gain parameters and network weights are well adapted to the discrete rounding operation used during inference.

3 Results and Discussion↩︎

3.1 Implementation Details↩︎

Training details. We trained EVOLVE on the 6,376 selected volumes listed in Table 4. For model architecture, we set \([C_1, C_2, C_3]\) to \([96, 192, 384]\) and \([L_1, L_2, L_3, L_4, L_5]\) to \([2, 2, 4, 1, 3]\). We set the number of latent channels \(M\) to 320 and the number of hyperlatent channels \(N\) to 256. For channel-context slicing, we split the latent channels unevenly into five groups with channel numbers \([16, 16, 32, 64, 192]\). The resulting EVOLVE model contains 85.6M parameters (\(\approx\)​327 MB in FP32). Unlike INRs, where the network itself is the compressed representation of a single volume, the same shared EVOLVE model can compress both seen and unseen in-domain volumes without per-volume optimization, and the reported CRs account for the per-volume bitstream. We used the AdamW optimizer [64] with an initial learning rate of \(10^{-4}\) and a weight decay of 0.01 for the encoder and decoder parameters. A separate optimizer with a learning rate of \(10^{-3}\) was used for other parameters, including the entropy model, as they exhibit different gradient scales and require a higher learning rate for stable convergence. We optimized our model for 1,600 epochs in total, with 800, 400, and 400 epochs for the three stages, respectively, and applied a linear warmup during the first 20 epochs at the beginning of each stage. In the second stage, we set the number of discrete quality levels \(A\) to 8 and \(\boldsymbol{\lambda}\) to [100, 200, 400, 800, 1,600, 3,200, 6,400, 12,800]. The training was conducted on an NVIDIA H200 GPU using a batch size of 24. For data augmentation, we randomly sampled 128\(\times\)​128\(\times\)​128 blocks from each dataset. If any dimension was smaller than 128, it was resized to allow block extraction. We additionally applied random axis-wise flipping and \(90^\circ\) rotations, each with 50% probability.

Baselines. For conventional lossy compressors, we chose ZFP [1], TTHRESH [2], and SZ3 [3], which represent state-of-the-art prediction-based and transform-based approaches. Since compressors are sensitive to their operating modes, we document the exact settings. TTHRESH uses target-PSNR mode (-p), and SZ3 uses an absolute error bound (-M ABS) derived from the target PSNR as \(\epsilon = r \cdot 10^{-\text{PSNR}/20}\), with \(r\) being the data range. ZFP is run in fixed-accuracy mode (-a), which adapts the per-block bit budget to a global error tolerance and generally attains higher CRs at a given quality than the fixed-rate mode (-r); even though it forgoes the fixed-size blocks and random access that fixed-rate mode provides. All operating points are selected so that each compressor meets the high-fidelity threshold (PSNR\(\geq\)​40 dB) for each dataset. For deep-learning-based compressors, we considered fully-connected INRs (SIREN [8], NeurComp [9], and ECNR [34]) that use MLPs to map coordinates to scalar values, grid-based INRs (Instant-NGP [33], fV-SRN [11], and AMGSRN++ [72]) that combine learnable feature grids with lightweight decoders for faster training and inference, and an AE-based method (IDLat [15]) that learns lightweight latent representations through convolutional encoding. Note that we did not compare with time-varying INR compression methods (e.g., KD-INR [10] and MoE-INR [73]), as EVOLVE focuses on static volume compression. For IDLat, we followed the original implementation and trained it on the same curated database as EVOLVE (see Table 4), using identical latent and hyperlatent dimensions for a fair comparison. For INR-based methods, we control the CR by adjusting their network hyperparameters, such as the number of hidden neurons for fully connected INRs and the feature grid resolution for grid-based INRs.

Testing datasets and metrics. All compression tests were conducted on a workstation with a single NVIDIA RTX 4090 GPU to ensure a fair comparison. We used the datasets listed in Table 1 for testing the compression performance of different methods. To prevent data leakage, the volumes in Table 1 have no overlap with the 9,921 volumes in Table 4, which are from unseen variables (combustion, half-cylinder, ionization) or new datasets (asteroids, gas, isotropic, magnetic). We assessed reconstruction quality using three complementary metrics: data-level peak signal-to-noise ratio (PSNR), image-level learned perceptual image patch similarity (LPIPS) [74], and surface-level Chamfer distance (CD) [75]. LPIPS quantifies perceptual differences by computing distances between deep features extracted from rendered images using AlexNet. CD evaluates geometric fidelity by measuring the average nearest-neighbor distance between isosurfaces extracted from decompressed and GT volumes using the L2 norm. The isovalues used for CD computation and isosurface rendering were manually selected per dataset to capture salient structures. Additional results with time-varying (asteroids-T, ionization-T) and ensemble (Nyx-E) datasets are presented in Appendices 9 and 10.

3.2 Comparison with Conventional Lossy Compressors↩︎

We compare EVOLVE with three representative conventional lossy compressors: ZFP, TTHRESH, and SZ3. All methods are evaluated in a high-fidelity reconstruction setting (i.e., PSNR\(\geq\)​40 dB) to ensure a fair comparison of compression efficiency without sacrificing reconstruction quality. Table 2 summarizes the averaged quantitative results across all datasets. In terms of CR, EVOLVE consistently achieves substantially higher CR than conventional compressors on unseen volumes, while maintaining superior reconstruction quality as measured by PSNR, LPIPS, and CD. In particular, on the asteroids dataset, EVOLVE reaches a CR of 9,803\(\times\), which is 3.95\(\times\) higher than the best conventional baseline, while simultaneously improving PSNR, LPIPS, and CD. Regarding runtime performance, EVOLVE achieves encoding speeds comparable to, and in some cases faster than, those of conventional compressors. The decoding stage is slower than the second-slowest baseline (TTHRESH) primarily due to additional operations, such as block merging. See Section 3.4 for comparisons at varying CRs. Figure 4 presents volume rendering comparisons on the combustion and ionization datasets. Although all compressors preserve the overall structure, the reconstructions from conventional methods exhibit noticeable artifacts and noise, particularly in the combustion zoom-in region. In contrast, EVOLVE yields high-fidelity renderings that better preserve fine-grained spatial details. Similarly, for isosurface renderings shown in Figure 5, ZFP and SZ3 exhibit noticeable roughness and jagged artifacts on the asteroids dataset, and TTHRESH introduces subtle distortions, whereas EVOLVE produces smoother, more geometrically consistent isosurfaces.

3.3 Comparison with Deep-Learning-Based Compressors↩︎

We compare EVOLVE with three categories of existing deep-learning-based compressors: fully connected INRs (SIREN, NeurComp, ECNR), grid-based INRs (Instant-NGP, fV-SRN, AMGSRN++), and the AE-based compressor IDLat. Following the same high-fidelity setting (PSNR\(\geq\)​40 dB), we tune the network capacity for INR-based methods to meet this quality threshold. For IDLat, since its CR is fixed once the model is trained on the same database as EVOLVE, we report its results directly without quality-based adjustment. Table 3 summarizes the quantitative comparisons across three test datasets. EVOLVE consistently achieves the highest CR while maintaining superior PSNR, LPIPS, and CD on all datasets. Moreover, thanks to its generalizability, EVOLVE performs compression via a feed-forward inference process without per-instance retraining, resulting in orders-of-magnitude faster encoding speeds than INR-based methods. Compared with IDLat, the improved efficiency and compression quality of EVOLVE stem primarily from the proposed context model and computationally efficient network designs, which enable faster, higher-quality compression. Specifically, on the magnetic dataset, EVOLVE achieves a CR of 10,774\(\times\) at 45.20 dB, surpassing the best INR method (AMGSRN++, 1,575\(\times\) at 44.23 dB) by nearly 7\(\times\) in CR while also improving quality.

In terms of visual quality, Figure 6 compares the volume rendering results between EVOLVE and fully connected INRs. Under comparable visual fidelity, EVOLVE achieves nearly 2\(\times\) higher CR than NeurComp while preserving sharper structural details. For more challenging datasets such as magnetic (Figure 7), both grid-based INRs and EVOLVE inevitably lose some high-frequency details under high CR. However, EVOLVE achieves a CR that is 5.9\(\times\) higher than that of fV-SRN, while avoiding the excessive over-smoothing artifacts observed in fV-SRN. Against IDLat, EVOLVE achieves much higher CR while maintaining comparable visual quality (Figure 8). The scale maps further reveal the entropy model’s spatially adaptive behavior. Compared with IDLat, EVOLVE allocates fewer bits to the relatively homogeneous upper regions of the gas volume, while assigning a relatively high bitrate to structurally complex areas near the bottom. This indicates that the proposed context modeling can exploit spatial redundancy, enabling more efficient bit allocation and leading to high CR.

3.4 Performance Evaluation under Various CRs↩︎

The comparisons in Sections 3.2 and 3.3 evaluate all methods at a single operating point under the high-fidelity setting (PSNR\(\geq\)​40 dB). Since scientific workflows often require flexible tradeoffs between quality and compression, we further compare how different methods perform across a range of CRs on the combustion (MF) and asteroids datasets. For EVOLVE, the variable-rate encoding mechanism (Section 2.3) enables a single trained model to produce a densely sampled rate-distortion curve by interpolating between learned gain values, without retraining or model switching. For conventional compressors (SZ3, TTHRESH), different CRs are obtained by varying their quality or error-bound parameters. For INR-based methods, each operating point requires a separately trained model with adjusted network capacity. ZFP is excluded from this comparison as its achievable CRs (refer to Table 2) fall well below the evaluated range, and IDLat is excluded because its fixed latent space dimensionality determines its CR.

Figure 9 presents the resulting rate-distortion curves measured in both PSNR and LPIPS. First, at comparable CRs, EVOLVE consistently achieves the highest PSNR among all evaluated methods on both datasets, demonstrating that the learned representations generalize well to unseen data across a wide range of rate-distortion operating points. Second, a single EVOLVE model spans a wide, continuous CR range via the learnable gain mechanism. The densely and smoothly sampled points along the EVOLVE curves confirm that the gain interpolation provides stable, fine-grained rate control without abrupt quality jumps. Third, while conventional compressors can also operate across multiple CRs by tuning their parameters, they exhibit steeper quality degradation as the CR increases. For instance, on the asteroids dataset, SZ3 achieves high PSNRs at low CRs but drops sharply beyond 3,000\(\times\), whereas EVOLVE maintains competitive reconstruction quality even at CRs exceeding 10,000\(\times\). Similarly, INR-based methods are generally confined to narrower CR ranges, and the LPIPS curves further corroborate these findings, showing that EVOLVE preserves superior perceptual quality across the entire evaluated CR range.

3.5 Deployment Considerations↩︎

Volume compression methods differ in where decompression is placed in the visualization pipeline. For some methods, decompression can be performed on demand at each frame during rendering (e.g., wavelet-based GPU compression [21], HVQ [4], dictionary-based sparse representations [5], [7], GPU-accelerated time-varying volume exploration [6], and grid-based INRs [11]–[13], [33]). In contrast, other methods require decompressing the whole volume before rendering.

EVOLVE belongs to the latter category. Its decoding latency, typically a few seconds per volume on a consumer GPU, is incurred only once per volume, not per frame. After decoding, all interactive operations, including transfer function editing, isovalue changes, and spatial navigation, proceed at native rendering rates. For time-varying data exploration, each timestep must likewise be decoded before visualization; future timesteps can be prefetched and decoded asynchronously while the current timestep is being inspected, hiding part of the switching latency. EVOLVE is therefore best suited when storage and transmission bandwidth savings outweigh the need for immediate random access to compressed timesteps. For transient rendering, strict timing constraints may limit the affordable decoding complexity and achievable CR; for offline storage, the autoregressive context model can trade decoding latency (refer to Tables 3) for substantially higher CRs.

Deployment also incurs a one-time overhead from the shared model itself (85.6M parameters), which is amortized over many encoded and decoded volumes.

4 Conclusions and Future Work↩︎

We have presented EVOLVE, an AE-based framework toward more generalizable learned volume compression for scientific data, shifting the focus from domain-specific optimization to unified representation learning. Its efficient, scalable design balances compression efficiency and reconstruction fidelity, and supports continuous variable-rate encoding within a single model, offering a practical path toward generalizable data-driven volumetric compression.

Several limitations remain. First, while our approach differs from prior works [34], [62], [76] by training a generalizable model on a large-scale database, the domains covered remain limited. In particular, our database contains only simulation data and no medical or microscopy volumes, whose noise characteristics and near-lossless requirements differ substantially; applying EVOLVE to such domains would require retraining with representative data. Second, training EVOLVE is computationally intensive, requiring a high-end GPU and a three-stage optimization schedule. Once trained on representative data from a domain, however, the model compresses both seen and unseen in-domain volumes without per-volume optimization, and inference runs on consumer-level GPUs. Finally, the current framework treats each volume independently, and leveraging temporal redundancy in time-varying simulations could further improve CRs.

5 Training Database Composition↩︎

Table 4 reports the full composition of the training database curated as described in Section 2.1. As exceptions, FIT and rotstrat are actually single static volumes with a resolution of 2,048\(\times\)​2,048\(\times\)​2,048, and we partition each volume into 512 subvolumes.

Nine datasets are multivariate or ensemble, each containing multiple physical variables or generated by different simulation parameters. Specifically, combustion [77] includes CHI, HR, VORTS, and YOH; explosion [78] includes RHO, P, and T; half-cylinder [79] provides VLM and VTM at three Reynolds numbers (160, 320, 640); hurricane [53] includes CLOUD, P, VAPOR, and WSMAG; ionization [80] includes GT, H, H\(_2\), He, He+, and PD; MHD [81] comprises RHO, MFM, and VLM; and Tangaroa [82] includes ACC, DIV, VLM, and VTM. In addition, gravity [83] and radiative-layer [84] contribute 17 and six distinct parameter combinations, respectively.

Each variable name denotes a physical quantity of the corresponding simulation. For combustion [77], CHI, HR, VORTS, and YOH refer to the scalar dissipation rate, heat release, vorticity magnitude, and OH mass fraction. For hurricane [53], a simulation of Hurricane Isabel, CLOUD, P, VAPOR, and WSMAG denote the total cloud moisture mixing ratio, atmospheric pressure, water vapor mixing ratio, and wind speed magnitude (computed from the U/V/W wind components), respectively. For ionization [80], which simulates radiation-driven ionization fronts in primordial gas with a nine-species chemistry network, GT and PD denote the gas temperature and particle density. In contrast, H, H\(_2\), He, He+, and H+ denote the abundances of neutral atomic hydrogen, molecular hydrogen, neutral helium, singly ionized helium, and ionized hydrogen, respectively. The remaining abbreviations follow common conventions (e.g., P for pressure, T for temperature, RHO for density, VLM/VTM for velocity/vorticity magnitude). For detailed information on these datasets, we refer readers to the corresponding entries in the Open SciVis Datasets [52], IEEE SciVis Contest archives [53], ETH Zürich visualization datasets [54], and Well [55].

For ionization, we remove the early and late timesteps that are largely empty and retain 100 content-rich timesteps for each variable.

6 Compression and Decompression API↩︎

EVOLVE provides a compression command and a decompression command. Tables 5 and 6 summarize the key parameters.

Compression. To compress a volume, the user specifies the input data directory, the pretrained model checkpoint, and the desired quality level. EVOLVE uses a continuous gain factor (--factor, float in \([0.0, 10.0]\)) for fine-grained bitrate control: larger values yield higher quality at lower CR. The volume is divided into overlapping blocks with configurable size and stride, enabling memory-efficient processing of arbitrary-resolution volumes.

Decompression. For decompression, only the compressed bitstream directory, the same model checkpoint, and the matching model configuration are needed. The volume resolution, block layout, and normalization ranges are automatically recovered from the stored meta info (refer to Appendix 7), so no additional data-specific parameters are required.

7 Compressed File Composition↩︎

Each EVOLVE compressed bitstream consists of three components: latent \(\hat{\boldsymbol{y}}\), hyperlatent \(\hat{\boldsymbol{z}}\), and meta info. The latent \(\hat{\boldsymbol{y}}\) is the entropy-coded output of the encoder, representing the primary signal content. It is partitioned into five channel slices, each further decomposed into anchor and non-anchor positions via a checkerboard pattern for context-based entropy coding. Because \(\hat{\boldsymbol{y}}\) has the same spatial resolution as the downsampled input (i.e., \(\frac{1}{16}\) along each axis), it carries the vast majority of the information and dominates the file size. The hyperlatent \(\hat{\boldsymbol{z}}\) serves as side information: the hyper-encoder compresses \(\hat{\boldsymbol{y}}\) into a much coarser representation (an additional 8\(\times\) spatial downsampling relative to \(\hat{\boldsymbol{y}}\)) to estimate the mean and scale parameters of the Gaussian entropy model. As a result, \(\hat{\boldsymbol{z}}\) is 8\(\times\)​8\(\times\)​8 = 512\(\times\) smaller than \(\hat{\boldsymbol{y}}\) in voxel count, and its contribution to the total bitstream is inherently small. The meta info is a fixed-cost overhead required for correct decoding. It includes: (1) a global header storing the volume resolution, number of blocks, and number of channel slices; (2) per-block headers recording spatial position, block size, normalization range (\(v_\text{min}\), \(v_\text{max}\)), and the byte lengths of \(\hat{\boldsymbol{y}}\) and \(\hat{\boldsymbol{z}}\) payloads; and (3) per-slice descriptors storing the byte lengths of anchor and non-anchor bitstreams within each slice. These fields are stored as fixed-width integers and floats, so meta info scales linearly with the number of patches but is independent of the data content.

Table 7 reports the composition breakdown on the combustion (MF) and isotropic datasets at two different CRs. Across all configurations, \(\hat{\boldsymbol{y}}\) dominates (75.5%–98.0% of the total file size). \(\hat{\boldsymbol{z}}\) accounts for only 1.3%–14.5%, and meta info contributes 0.7%–10.0%. At higher CRs (smaller files), the fixed-cost meta info and \(\hat{\boldsymbol{z}}\) occupy a proportionally larger share. At lower CRs (larger files), \(\hat{\boldsymbol{y}}\) grows disproportionately, reaching 95–98% of the total, confirming that the overhead of \(\hat{\boldsymbol{z}}\) and meta info is negligible.

8 Inference Memory Footprint↩︎

EVOLVE compresses a volume by partitioning it into 128\(\times\)​128\(\times\)​128 blocks, each encoded and decoded independently, streaming a single block to the GPU at a time. Table ¿tbl:tab:memory? reports the peak GPU and host (CPU) memory during compression on a single NVIDIA RTX 4090, measured with nvidia-smi (per-process GPU memory) and the peak resident set (VmHWM), for two test volumes, asteroids (1,000\(\times\)​1,000\(\times\)​1,000, 3.7 GB) and gas (512\(\times\)​512\(\times\)​512, 512 MB), at two different compression rates. Since only one block resides on the GPU at any time, the GPU memory holds just the network parameters and the activations of the current block, and is therefore constant (\(\sim\)​2.7 GB) regardless of the volume size. The host memory instead holds the full input volume, its reconstruction, and the accumulated bitstream, and thus grows with the volume size. For a given volume, the footprint is independent of the target rate. This constant and modest GPU footprint allows EVOLVE to compress even gigabyte-scale volumes on a single consumer GPU (see Section 3.5). For volumes whose reconstruction exceeds the host memory, one can partition them into smaller subvolumes and process them sequentially.

9 Latent Space Exploration and Analysis↩︎

Similar to other autoencoder-based methods [15], [16], [85], the latent vectors extracted from the pretrained EVOLVE model are interpretable. In Figure 10, we compare the representative timestep selection results for the ionization-T (H+) dataset using the importance-driven framework proposed by Wang et al. [86] and EVOLVE. For EVOLVE, following [85], we project the latent vectors extracted from all volumes into 2D using t-SNE, with each point corresponding to a timestep. We then connect neighboring timesteps to form a trajectory in the latent space and select representative timesteps based on the arclength and angle metrics computed along this trajectory. Compared with the information-theoretic selection shown in Figure 10 (a), we can observe that EVOLVE produces a more balanced temporal coverage, as shown in Figure 10 (b). Early formation stages, transitions, and stabilization phases remain consistently represented. This result highlights the potential of EVOLVE for volume analysis applications.

10 Compression of Time-Varying and Ensemble Data↩︎

EVOLVE compresses time-varying and ensemble datasets by independently compressing each volume. Table 8 reports the average quantitative results of our method on the asteroids-T and Nyx-E datasets under three quality settings (high, medium, and low), which correspond to decreasing gain factors that trade reconstruction quality for higher CRs. asteroids-T is a time-varying dataset containing 220 timesteps; we select two timesteps (\(t\)=165 and \(t\)=219) for visualization. Nyx-E is an ensemble dataset with varying cosmological simulation parameters; we select two members (\(\Omega_M\)=0.126 and \(\Omega_M\)=0.155) for visualization. The volume rendering results are shown in Figure 11. We observe that our method faithfully reconstructs volumes across all three quality levels. Future work will focus on incorporating additional temporal or ensemble information into the context model to achieve higher CRs.

11 Additional Rendering Results↩︎

Due to page limits, the main paper only presents a subset of rendering comparisons. In Figures 12, 13, 14, and 15, we provide the complete set of volume rendering and isosurface rendering results across all test datasets, comparing EVOLVE with both conventional lossy compressors and deep-learning-based compressors at their respective CRs and reconstruction quality.

12 Evaluation of Scanned Volumetric Data↩︎

To assess how EVOLVE behaves outside its training distribution, we evaluate it on four scanned volumes from the Open SciVis Datasets [52]: chameleon (1,024\(\times\)​1,024\(\times\)​1,080), engine (256\(\times\)​256\(\times\)​128), foot (256\(^3\)), and stag-beetle (832\(\times\)​832\(\times\)​494), all normalized to \([0,1]\) in FP32. We compare EVOLVE (the released model, without any retraining) against ZFP, TTHRESH, and SZ3. For each dataset, EVOLVE operates at the high-quality level. Table ¿tbl:tab:scan-results? reports the quantitative results, and Figure 16 presents the corresponding rendering results. Because these scanned volumes fall outside EVOLVE’s training distribution, its overall benefit here is limited: although EVOLVE still edges out the conventional compressors on chameleon, engine, and stag-beetle, the margin on engine is small. For foot, its quality saturates at 33.7 dB and cannot be improved further by increasing the rate budget. This demonstrates the necessity of training on broader, more diverse data to further improve EVOLVE’s performance and generalization across a wider range of volumes.

References↩︎