Wavelet Latent Diffusion (WaLa): Billion-Parameter 3D Generative Model with Compact Wavelet Encodings

## Abstract

Abstract Large-scale 3D generative models require substantial computational resources yet often fall short in capturing fine details and complex geometries at high resolutions. We attribute this limitation to the inefficiency of current representations, which lack the compactness required to model the generative models effectively. To address this, we introduce a novel approach called Wa velet La tent Diffusion, or WaLa , that encodes 3D shapes into a wavelet-based, compact latent encodings. Specifically, we compress a 256 3 superscript 256 3 256^{3} 256 start_POSTSUPERSCRIPT 3 end_POSTSUPERSCRIPT signed distance field into a 12 3 × 4 superscript 12 3 4 12^{3}\times 4 12 start_POSTSUPERSCRIPT 3 end_POSTSUPERSCRIPT × 4 latent grid, achieving an impressive 2,427× compression ratio with minimal loss of detail. This high level of compression allows our method to efficiently train large-scale generative networks without increasing the inference time. Our models, both conditional and unconditional, contain approximately one billion parameters and successfully generate high-quality 3D shapes at 256 3 superscript 256 3 256^{3} 256 start_POSTSUPERSCRIPT 3 end_POSTSUPERSCRIPT resolution. Moreover, WaLa offers rapid inference, producing shapes within two to four seconds depending on the condition, despite the model’s scale. We demonstrate state-of-the-art performance across multiple datasets, with significant improvements in generation quality, diversity, and computational efficiency. We open-source our code and, to the best of our knowledge, release the largest pretrained 3D generative models across different modalities: https://github.com/AutodeskAILab/WaLa . Figure 1: We propose a new 3D generative model, called WaLa, that can generate shapes from conditions such as sketches, text, single-view images, low-resolution voxels, point clouds & depth-maps.

## 1 Introduction

Training generative models on large-scale 3D data presents significant challenges. The cubic nature of 3D data drastically increases the number of input variables the model must handle, far exceeding the complexity found in image and natural language tasks. This complexity is further compounded by storage and streaming issues. Training such large models often requires cloud services, which makes the process expensive for high-resolution 3D datasets as these datasets take up considerable space and are slow to stream during training. Additionally, unlike other data types, 3D shapes can be represented in various ways, such as voxels, point clouds, meshes, and implicit functions. Each representation presents different trade-offs between quality and compactness. Determining which representation best balances high fidelity with compactness for efficient training and generation remains an open challenge. Finally, 3D representations often exhibit complex hierarchical structures with details at multiple scales, making it challenging for a generative model to capture both global structure and fine-grained details simultaneously.

Figure: Figure 2: WaLa generates 3D shapes across various input modalities (see appendix for more).
Refer to caption: x2.png

To address these challenges, current state-of-the-art methods for large generative models typically employ three main strategies. The first strategy involves using low-resolution representations, such as sparse point clouds  (Nichol et al., ; Jun & Nichol, ), low-polygon meshes  (Chen et al., ), or coarse grids  (Cheng et al., ; Sanghi et al., ). While these approaches reduce computational complexity, they are limited in their ability to model the full distribution of 3D shapes, struggle to capture intricate details, and often lead to lossy representations. The second approach represents 3D shapes through a collection of 2D images  (Yan et al., ) or incorporates images  (Hong et al., ; Li et al., ; Liu et al., ; Xu et al., ; Siddiqui et al., ; Bensadoun et al., ) into the training loss. However, this method suffers from long training times due to the need for rendering and can fail to capture internal details of 3D shapes, as it primarily focuses on external appearances. The third strategy introduces more compactness into the input representations  (Hui et al., ; Zhou et al., ; Ren et al., ; Yariv et al., ; Xiong et al., ; Zhang et al., ) to reduce the number of variables the generative model must handle. While these representations can be sparse  (Ren et al., ; Yariv et al., ; Xiong et al., ), they are often irregular or discrete in nature making it challenging to be modeled via neural networks and can still be relatively large compared to image or natural language data  (Hui et al., ; Zhou et al., ), thus making it difficult to scale the model parameters efficiently.

One prominent compact input representation is wavelet-based representation, which includes Neural Wavelet (Hui et al., ), UDiFF (Zhou et al., ), and wavelet-tree frameworks (Hui et al., ). These methods utilize wavelet transforms and their inverses to seamlessly convert between wavelet spaces and high-resolution truncated signed distance function (TSDF) representations. They offer several key advantages: data can be easily compressed by discarding selected coefficients with minimal loss of detail, and the interrelationships between coefficients facilitate efficient storage, streaming, and processing of large-scale 3D datasets compared to directly using TSDFs (Hui et al., ). However, despite these benefits, wavelet-based representations remain substantially large, especially when scaling up for large-scale generative models. For example, a $256^{3}$ TSDF can be represented as a wavelet-tree of size $46^{3}\times 64$ (Hui et al., ), which is equivalent to a $1440\times 1440$ RGB image. Scaling within this space continues to pose significant challenges.

In this work, we build upon the wavelet representation described above and introduce the *Wavelet Latent Diffusion* (WaLa) framework. This framework further compresses the wavelet representation to obtain compact latent encodings without significant information loss, thereby efficiently enabling us to scale a diffusion-based generative model within this space. Starting with a truncated signed distance function (TSDF) of a shape, we first convert it into 3D wavelet tree representation as in  Hui et al. (). Then, we train a convolution-based VQ-VAE model with adaptive sampling loss and balanced fine-tuning to compress a $256^{3}$ TSDF into a $12^{3}\times 4$ grid, achieving a remarkable $2,427\times$ compression ratio while maintaining an impressive reconstruction without a significant loss of detail. For example, as shown in Table 1, an Intersection over Union (IOU) of 0.978 is achieved on the GSO dataset. Compared to other representations, this approach requires fewer input variables for the generative model while retaining high reconstruction accuracy. Consequently, the generative model does not need to model local details and can focus on capturing the global structure. Moreover, by significantly reducing the number of input variables that the generative model must handle due to this compression, we enable the training of large-scale 3D generative models with up to a billion parameters, producing highly detailed and diverse shapes. WaLa also supports controlled generation through multiple input modalities without adding significant inductive biases, making the framework flexible and adaptable beyond single-view 3D reconstruction tasks. As a result, our model generates 3D shapes with complex geometry, plausible structures, intricate topologies, and smooth surfaces. This is demonstrated in Figures 1
and 2, where high-quality 3D meshes can be obtained by applying marching cubes to the SDF generated from different input modalities such as text, sketch, low-resolution voxel, point cloud, single-view, and multi-view images.

In summary, we make the following contributions:

- •
We introduce a *Wavelet Latent Diffusion* (WaLa) framework that tackles the dimensional and computational challenges of 3D generation with impressive compression while maximizing fidelity.
- •
Our large billion-parameter model generates high-quality 3D shapes within two to four seconds, significantly outperforming state-of-the-art benchmarks in 3D shape generation.
- •
Our model demonstrates exceptional versatility, accepting diverse input modalities such as single/multi-view images, voxels, point clouds, depth data, sketches, and textual descriptions (see Figure  1 and  2), making it applicable to a wide range of 3D modeling tasks.
- •
To foster reproducibility and stimulate further research in this domain, we release what we believe is, to the best of our knowledge, the largest 3D generative model to date that works across various input modalities, comprising approximately one billion parameters. The model is available at [https://github.com/AutodeskAILab/WaLa](https://github.com/AutodeskAILab/WaLa).

**Table 1: 3D representations compared on GSO dataset (Downs et al., ): Intersection over Union (IoU) for accuracy & number of input variables for generative models to evaluate complexity.**
| Representation | IoU | Number of Input Variables |
| --- | --- | --- |
| Ground-truth SDF ($256^{3}$) | $1.0$ | $16,777,216$ ($\sim 64\text{MB}$) |
| Point Cloud (Nichol et al., ) | $0.8642$ | $12,288$ ($\sim 0.05\text{MB}$) |
| Latent Vectors (Jun & Nichol, ) | $0.8576$ | $1,048,576$ ($\sim 4\text{MB}$) |
| Coarse Component (Hui et al., ) | $0.9531$ | $97,336$ ($\sim 0.4\text{MB}$) |
| Wavelet tree (Hui et al., ) | $0.9956$ | $1,129,528$ ($\sim 4.3\text{MB}$) |
| WaLa | $0.9780$ | $6,912$ ($\sim 0.03\text{MB}$) |

## 2 Related Work

Neural Shape Representations.
Several representations have been explored for Deep learning for 3D data. Initially, volumetric methods using 3D convolutional networks were employed (Wu et al., ; Maturana & Scherer, ), but they were limited by resolution and efficiency. The field then advanced to multi-view CNNs that apply 2D processing to rendered views (Su et al., ; Qi et al., ), and further explored sparse point cloud representations with networks like PointNet and its successors (Qi et al., ; ; Wang et al., ). Additionally, neural implicit representations for compact, continuous modeling were developed (Park et al., ; Mescheder et al., ; Chen & Zhang, ). Explicit mesh-based and boundary representations (BREP) have gained attention, enhancing both discriminative and generative capabilities in CAD-related applications (Hanocka et al., ; Chen et al., ; Jayaraman et al., ; Lambourne et al., ). Recently, wavelet representations  (Hui et al., ; Zhou et al., ; Hui et al., ) have become popular.
Wavelet decompositions of SDF signals enable tractable modeling of high-resolution shapes.
In this work, we extend the previous research by addressing the dimensional and computational hurdles of 3D generation. Our novel techniques for efficient shape processing enable high-quality 3D generation at scale, accommodating datasets with millions of shapes.

3D Generative Models.
3D generative models have evolved rapidly, initially dominated by Generative Adversarial Networks (GANs) (Goodfellow et al., ; Wu et al., ). Subsequent advancements integrated differentiable rendering with GANs, utilizing multi-view losses for enhanced fidelity (Chan et al., ). Parallel developments explored normalizing flows (Yang et al., ; Klokov et al., ; Sanghi et al., ) and Variational Autoencoders (VAEs) (Mo et al., ). Additionally, autoregressive models also gained traction for their sequential generation capabilities (Cheng et al., ; Nash et al., ; Sun et al., ; Mittal et al., ; Yan et al., ; Zhang et al., ; Sanghi et al., ).
The recent success of diffusion models in image generation has sparked a great interest in their application to 3D contexts. Most current approaches employ a two-stage process: first, a Vector-Quantized VAE (VQ-VAE) on 3D representations such as triplanes (Shue et al., ; Chou et al., ; Peng et al., ; Reddy et al., ; Siddiqui et al., ; Chen et al., ; Gao et al., ; Shue et al., ), implicit forms (Zhang et al., ; Li et al., ; Cheng et al., ), or point clouds (Jun & Nichol, ; Zeng et al., ) is trained, and then, diffusion models are applied to the resulting latent space. Incorporating autoencoders to process latent spaces allow for the generation of complex representations like point clouds (Jun & Nichol, ; Zeng et al., ) and implicit forms (Zhang et al., ; Li et al., ; Cheng et al., ; Zhang et al., ). Direct training of diffusion models on 3D representations, though less explored, has shown promise for point clouds (Nichol et al., ; Zhou et al., ; Luo & Hu, ; Nakayama et al., ), voxels (Zheng et al., ), occupancy (Ren et al., ), and neural wavelet coefficients (Hui et al., ; Liu et al., ; Hui et al., ).
Our work advances this frontier by bridging the gap between compact representation and high-fidelity generation.

Conditional 3D Models.
Two primary paradigms dominate conditional 3D generative models, each with its own approach to 3D content creation.
The first paradigm ingeniously repurposes large-scale 2D conditional image generators, such as  (Rombach et al., ) or Imagen (Saharia et al., ), for 3D synthesis. This approach employs a differentiable renderer to project 3D shapes into 2D images, enabling comparison with target images or alignment with text-to-image model distributions  (Jain et al., ; Michel et al., ; Poole et al., ). Initially focused on text-to-3D generation, this method has expanded to accommodate various input modalities, including single and multi-view images (Deng et al., ; Melas-Kyriazi et al., ; Xu et al., ; Liu et al., ; Deitke et al., ; Qian et al., ; Shi et al., ; Wang et al., ; Liu et al., ), and even sketches (Mikaeili et al., ).
This approach, while novel, is limited by its computational demands. An alternative paradigm uses dedicated conditional 3D generative models trained on either paired datasets or through zero-shot learning. These paired models show adaptability to various input conditions,
ranging from point clouds (Zhang et al., ; ) and images (Zhang et al., ; Nichol et al., ; Jun & Nichol, ; Zhang et al., ; Chen et al., ; Tang et al., ; Li et al., ; Xu et al., ; Zhang et al., ; Siddiqui et al., ; Bensadoun et al., ) to low-resolution voxels (Chen et al., ; ), sketches (Lun et al., ; Guillard et al., ; Gao et al., ; Kong et al., ), and textual descriptions (Nichol et al., ; Jun & Nichol, ; Ren et al., ; Yariv et al., ). Concurrently, zero-shot methods have gained traction, particularly in text-to-3D (Sanghi et al., ; ; Liu et al., ; Xu et al., ; Yan et al., ) and sketch-to-3D applications (Sanghi et al., ), showcasing the potential for more flexible and generalizable 3D generation.
We expand on the second paired paradigm, developing a large-scale paired conditional generative model for 3D shapes. This approach enables fast generation without per-instance optimization, supports diverse inputs, and facilitates unconditional generation and zero-shot tasks like shape completion.

## 3 Method

Figure: Figure 3: Overview of the WaLa network architecture and 2-stage training process and inference method. Top Left: Stage 1 autoencoder training, compressing diffusible wavelet tree ($W$) shape representation into a compact latent space. Top Right: Conditional/unconditional diffusion training. Bottom: Inference pipeline, illustrating sampling from the trained diffusion model and decoding the sampled latent into a Wavelet Tree ($W$), then into a mesh.
Refer to caption: x3.png

Training generative models on large-scale 3D data is challenging because of the data’s complexity and size. This has driven the creation of compact representations like neural wavelets, facilitating efficient neural network training. To represent a 3D shape with wavelets, it is first converted into a Truncated Signed Distance Function (TSDF) grid.
A wavelet transform is then applied to decompose this TSDF grid into coarse coefficients ($C_{0}$) and detail coefficients at various levels ($D_{0}$, $D_{1}$, $D_{2}$). Various wavelet transforms, such as Haar, biorthogonal, or Meyer wavelets, can be employed. Most current methods utilize the biorthogonal wavelet transform (Hui et al., ; Zhou et al., ; Hui et al., ). The coarse coefficients primarily capture the essential shape information, while the detail coefficients represent high-frequency details. To compress this representation, different filtering schemes can be applied to remove certain coefficients, though this involves a trade-off in reconstruction quality. In the neural wavelet representation (Hui et al., ), all detail coefficients are discarded during the training of the generative model and a regression network is used to predict the missing detail coefficients $D_{0}$. In contrast, the wavelet-tree representation (Hui et al., ) retains all coarse coefficients ($C_{0}$), discards the third level of detail coefficients ($D_{2}$), and selectively keeps the most significant coefficients from $D_{0}$ along with their corresponding details in $D_{1}$ using a subband coefficient filtering scheme. The neural wavelet representation, while modeling a smaller number of input variables, has lower reconstruction quality than the wavelet-tree representation, making latter a more attractive option.

Building upon these efficient wavelet representations, our method requires a large collection of 3D shapes. Let $\mathcal{S}=\left\{\left(W_{n},\Theta_{n}\right)\right\}_{n=1}^{N}$, denote a dataset of $N$ 3D shapes such that each shape $S_{n}\in\mathcal{S}$ is represented by a diffusible wavelet tree representation $W_{n}$ (Hui et al., ) and an optional associated condition $\Theta_{n}$. The representation $W_{n}\in\mathbb{R}^{46^{3}\times 64}$ is obtained by converting a TSDF of resolution $256^{3}$. Depending on the conditional generative model, the condition $\Theta_{n}$ can be a single-view image, multi-view images, a voxel representation, a point cloud, or multi-view depth maps, and may be omitted if the model is unconditional or when training the vector-quantized autoencoder (VQ-VAE). Training our model comprises two stages: First, we train a convolution-based VQ-VAE to encode the diffusible wavelet tree representation into a more compact grid latent space $Z$ using the adaptive sampling loss. At this stage, to further enhance reconstruction accuracy, we fine-tune the VQ-VAE using a simple approach we call balanced fine-tuning. This VQ-VAE encodes a latent grid $Z_{n}\in\mathbb{R}^{12^{3}\times 4}$ for each shape $S_{n}\in\mathcal{S}$. In the second stage, we train a diffusion-based generative model on this latent grid $Z_{n}$ that can be conditioned on a sequence of condition vectors derived from one of the aforementioned conditions. During inference, we initiate with a completely noisy latent vector and employ the conditional generative network to denoise it progressively through the inverse diffusion process, utilizing classifier-free guidance. The two-step process is detailed in Figure  3 and is also explained next.

### 3.1 Stage 1: Wavelet VQ-VAE

Our primary objective is to compress the diffusible wavelet tree representation (Hui et al., ) into a compact latent space without significant loss of fidelity, thereby facilitating the training of a generative model directly on this latent space. Decoupling compression from generation allows for efficient scaling of a large generative model within the latent space. To this end, we employ a convolution-based VQ-VAE, known for producing sharper reconstructions and mitigating issues like posterior collapse (Van Den Oord et al., ; Razavi et al., ; Baykal et al., ). Specifically, the encoder $Enc(\cdot)$ maps the input $W_{n}$ to a latent representation $Z_{n}=Enc(W_{n})$, which is then quantized as $\mathrm{VQ}(Z_{n})$ via a vector quantization layer and decoded by $Dec(\cdot)$ to reconstruct the shape $W_{n}^{\prime}=Dec(\mathrm{VQ}(Z_{n}))$. By integrating the vector quantization layer with the decoder, as in (Rombach et al., ), we ensure that the generative model is trained on pre-quantized latent codes. This approach leverages the robustness of the quantization layer to small perturbations by mapping generated codes to the nearest embeddings in a codebook after generation. Empirical results confirm the effectiveness of this strategy, see Ablation Section C.4.

To train the VQ-VAE, we employ a combination of three losses: a reconstruction loss to ensure fidelity between the original and reconstructed shapes, a codebook loss to encourage the codebook embeddings to adapt to the distribution of encoder outputs, and a commitment loss to align the encoder’s outputs closely with the codebook embeddings.
We apply a reconstruction loss $\mathcal{L}_{\text{rec}}(W_{n},W_{n}^{\prime})$, during which we adopt a adaptive sampling loss strategy  (Hui et al., ) to focus more effectively on high-magnitude detail coefficients (i.e., $D_{0}$ and $D_{1}$) while still considering the others. Since most detail coefficients are low in magnitude and contribute minimally to the overall shape quality, this approach identifies the significance of these coefficients in each subband based on their magnitude relative to the largest coefficient, forming a set $P_{0}$ of important coordinates. By structuring the training loss to emphasize these crucial coefficients and incorporating random sampling of less important ones, the model efficiently concentrates on key information without neglecting finer details. This is formalized in the equation below:

$$ $\mathcal{L}_{\text{rec}}=L_{\text{MSE}}(C_{0},C^{\prime}_{0})+\frac{1}{2}\sum_ {D\in\{D_{0},D_{1}\}}\left[L_{\text{MSE}}(D[P_{0}],D^{\prime}[P_{0}])+L_{\text {MSE}}(R(D[P_{0}^{\prime}]),R(D^{\prime}[P_{0}^{\prime}]))\right]$ (1) $$

In this context, $L_{\text{MSE}}(X,Y)$ denotes the mean squared error between $X$ and $Y$. The coefficients $C_{0},D_{0},D_{1}$ extracted from $W_{n}$ represent the coarse and detail components, respectively, while their reconstructed counterparts $C^{\prime}_{0},D^{\prime}_{0},D^{\prime}_{1}$ are derived from the reconstructed $W^{\prime}_{n}$. The notation $D[P_{0}]$ refers to the coefficients in $D$ at the positions specified by the set $P_{0}$, with $P_{0}^{\prime}$ being its complement. The function $R(D[P_{0}^{\prime}])$ randomly selects coefficients from $D[P_{0}^{\prime}]$ such that the number of selected coefficients equals $|P_{0}|$. By balancing the number of coefficients in the last two terms of the loss function, we emphasize critical information while regularizing less significant coefficients through random sampling. This approach is also empirically validated in Ablation Section  C.1.

Our model is initially trained on 10 million samples collected from 19 different datasets (see Section 4.1 for details). However, we observed that a substantial portion of this data is skewed towards simple CAD objects, introducing a bias in the training process. This imbalance can cause the model to underperform on more complex or less-represented 3D shapes. To address this issue, we fine-tune the converged VQ-VAE model using an equal number of samples from each of the 19 datasets — a process we call balanced fine-tuning. This approach ensures that the model is exposed uniformly to the diverse range of shapes and complexities present across all datasets, thereby reducing the bias introduced by the initial imbalance. Empirically, we find that balanced fine-tuning enhances reconstruction results across datasets, as demonstrated in our ablation study (Section C.2).

### 3.2 Stage 2: Latent Diffusion model

In the second stage, we train a large-scale generative model with billions of parameters on the latent grid, either as an unconditioned model to capture the data distribution or conditioned on diverse modalities $\Theta_{n}$ (e.g., point clouds, voxels, images). We use a diffusion model within the Denoising Diffusion Probabilistic Models (DDPM) framework  (Ho et al., ), modeling the generative process as a Markov chain with two phases.

First, the forward diffusion process gradually adds Gaussian noise to the initial latent code $Z_{n}^{0}$ over $T$ steps, resulting in $Z_{n}^{T}\sim\mathcal{N}(0,I)$. Then, the reverse denoising process employs a generator network $\theta$, conditioned on $\Theta_{n}$, to systematically remove the noise and reconstruct $Z_{n}^{0}$. The generator predicts the original latent code $Z_{n}^{0}$ from any intermediate noisy latent codes $Z_{n}^{t}$ at time step $t$, using $f_{\theta}(Z_{n}^{t},t,\Theta_{n})\approx Z_{n}^{0}$, and is optimized using a mean-squared error loss:

$$ $\mathcal{L}=\mathbb{E}_{t}\left[\|f_{\theta}(Z_{n}^{t},t,\Theta_{n})-Z_{n}^{0} \|^{2}\right]$ $$

Here, $Z_{n}^{t}$ is obtained by adding Gaussian noise $\epsilon$ to $Z_{n}^{0}$ at time step $t$ using a cosine noise schedule  (Dhariwal & Nichol, ). The condition $\Theta_{n}$ is a latent set of vectors derived from various conditioning modalities, injected into the U-ViT generator  (Hoogeboom et al., ) by using cross-attention and by modulating the normalization parameters in the ResNet and cross-attention layers, as described in  Esser et al. (). This is achieved via condition encoders for different modalities. During training, we apply a small dropout to the condition to implement classifier-free guidance during inference. In the case of unconditional generation, no conditioning is applied. For most input conditions (point clouds, voxels, images, multi-view images, and multi-view depth) we directly train a different conditional generative model for each condition, while for the conditioning on sketch and the single-depth, we take the image-conditioned generative model and fine-tune it with synthetic sketch data and depth data, respectively. For text-to-3D, we fine-tune MVDream (Xu et al., ) to generate six multi-view depth images, as this provides better reconstruction than multi-view images (see experiments in Section  4.2.3), and then use our model during inference. Further details are provided in the appendix.

### 3.3 Inference

At test time, we begin with a randomly generated noisy latent encoding $Z_{n}^{T}\sim\mathcal{N}(0,I)$ and iteratively denoise it to reconstruct the original latent code $Z_{n}^{0}$ through the reverse diffusion process, as described in DDPM  (Ho et al., ). For conditional generation, we apply classifier-free guidance  (Ho & Salimans, ) by interpolating between the unconditional and conditional denoising predictions, steering the generation process toward the desired output. This approach allows for greater control over the quality-diversity trade-off. Once the final latent code $Z_{n}^{0}$ is obtained, we use the pre-trained decoder network of the VQ-VAE from 3.1 to generate the final 3D shape in the wavelet form. Subsequently, we apply the inverse wavelet transform to obtain the final 3D shape as an TSDF that can further be converted to a mesh using marching cubes. Notably, we can generate multiple samples for the same conditional input by using different initializations of the noisy latent grid.

## 4 Results

### 4.1 Experimental Setup

Datasets.
Our training data consists of over 10 million 3D shapes, assembled from 19 publicly available datasets, including ModelNet Vishwanath et al. (),
ShapeNet Chang et al. (),
SMPL Loper et al. (),
Thingi10K Zhou & Jacobson (),
SMAL Zuffi et al. (),
COMA Ranjan et al. (),
House3D Wu et al. (),
ABC Koch et al. (),
Fusion 360 Willis et al. (),
3D-FUTURE Fu et al. (),
BuildingNet Selvaraju et al. (),
DeformingThings4D Li et al. (),
FG3D Liu et al. (),
Toys4K Stojanov et al. (),
ABO Collins et al. (),
Infinigen Raistrick et al. (),
Objaverse Deitke et al. (),
and two subsets of ObjaverseXL Deitke et al. () (Thingiverse and GitHub).
These individual datasets target specific object categories: for instance, CAD models (ABC and Fusion 360), furniture (ShapeNet, 3D-FUTURE, ModelNet, FG3D, ABO), human figures (SMPL and DeformingThings4D), animals (SMAL and Infinigen), plants (Infinigen), faces (COMA), and houses (BuildingNet, House3D). Additionally, Objaverse and ObjaverseXL cover a broader range of generic objects sourced from the internet, covering the aforementioned categories and other diverse objects.
Following Hui et al. (), each of these 19 datasets was split into two parts for data preparation: $98\%$ of the shapes were allocated for training, and the remaining $2\%$ for testing. The final training and testing sets were created by merging the corresponding portions from each sub-dataset. Note that we use the entire testing dataset solely for autoencoder reconstruction validation.
We also apply a 90-degree rotation augmentation along each axis, doing the same for the corresponding conditions (point clouds, voxels).
We also create a balanced training set across these 19 datasets by sampling 10,000 shapes from each. If a dataset contains fewer than 10,000 shapes, we duplicate the data until the target size is reached.

Training Details.
For optimization and training, we use the Adam optimizer Kingma & Ba () with a learning rate of $0.0001$ and a gradient clipping value of $1$. For VQ-VAE training, we use a batch size of $256$ with $1024$ codebook embeddings of dimension $4$. We train the network until convergence and then fine-tune the VQ-VAE using a more balanced dataset until it converges again. For the base generative model, we use a batch size of $64$ and train it for $2$ to $4$ million iterations for each modality. Each generative model is trained on a single H100 GPU per condition. We train our model on six conditions: point clouds with $2,500$ points, voxels at $16^{3}$ resolution, single-view RGB, multi-view RGB with $4$ views, multi-view depth with $4$ views, and multi-view depth with $6$ views. We also fine-tune the single-view model with synthetic sketch data and single-depth data to obtain two more conditions. Additionally, we train an unconditional model beyond these. Finally, we train a large single-view RGB model with 1.4 billion parameters, which we call the WaLa Large model, using 8 H100 GPUs and a batch size of 256. Once this model has converged, we fine-tune it with depth data, using the same number of GPUs and batch size, to obtain the WaLa Depth Large model.

Evaluations Dataset.
We perform qualitative and quantitative evaluation of our method on Google Scanned Objects (GSO) (Downs et al., ) and MAS validation data (Hui et al., ).
Importantly, Google Scanned Objects (GSO) is not a part of the dataset detailed in Section 4.1 used to train our model. Consequently, evaluating on Google Scanned Objects (GSO) data assesses the cross-domain generalization of our method. We include all validation objects from the GSO dataset to ensure a broad evaluation.
The MAS validation data is an unseen test set consisting of 50 randomly selected shapes from each of the 19 large-scale datasets mentioned in Section 4.1.
This ensures that validation data contains all the subcategories like CAD models, human figures, faces, houses, and others, thereby enabling a comprehensive evaluation. We present three metrics for each method on both datasets, the metrics being: (i) Light Field Distance
(LFD) (Chen et al., ) which evaluates how alike two 3D models appear when viewed from multiple angles, (ii) Intersection over Union (IoU) ratio, which compares the intersection volume to the total volume of two voxelized 3D objects, and (iii) Chamfer Distance (CD), which measures the similarity between two shapes based on the minimum distance between corresponding points on their surfaces. Note that among these three metrics, for generated shapes that are not aligned (that can occur during generation from conditions such as single images), the most reliable metric is LFD as it is rotation invariant.

### 4.2 Experiments

We conducted a comprehensive study across various modalities, quantitatively evaluating our method against baselines using four distinct input types: point clouds (Section 4.2.1), voxels (Section 4.2.2), single-view images, and multi-view images (Section 4.2.3). For qualitative analysis, we present the results of all our models, showcasing visual outcomes in Figure  1 and Figure  2, and provide additional examples in the appendix as well as on our website: [https://autodeskailab.github.io/WaLaProject](https://autodeskailab.github.io/WaLaProject). We also report a detailed ablation study in the appendix.

Figure: Figure 4: Qualitative comparison with other methods for single-view (top-left), multi-view (top-right), voxels (bottom-left), and point cloud (bottom-right) conditional input modalities. Hui et al. (); He & Wang (); Tochilkin et al. (); Xu et al. (); Tang et al. (); Chen et al. (); Nichol et al. ()
Refer to caption: x4.png

#### 4.2.1 Point cloud-to-Mesh

**Table 2: Quantitative comparison between different methods of point cloud to mesh generation. We present LFD, IOU and CD metrics. Our method, WaLa, outperforms the other methods on both GSO and MAS Validation datasets.**
| Method | GSO Dataset | MAS Dataset |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| LFD $\downarrow$ | IoU $\uparrow$ | CD $\downarrow$ | LFD $\downarrow$ | IoU $\uparrow$ | CD $\downarrow$ |  |
| Poisson surface reconstruction (Kazhdan et al., ) | 3306.66 | 0.3838 | 0.0055 | 4565.56 | 0.2258 | 0.0085 |
| Point-E SDF model (Nichol et al., ) | 2301.96 | 0.6006 | 0.0037 | 4378.51 | 0.4899 | 0.0158 |
| MeshAnything (Chen et al., ) | 2228.62 | 0.3731 | 0.0064 | 2892.13 | 0.3378 | 0.0091 |
| Make-A-Shape (Hui et al., ) | 2274.92 | 0.7769 | 0.0019 | 1857.84 | 0.7595 | 0.0036 |
| WaLa(Ours) | 1114.01 | 0.9389 | 0.0011 | 1467.55 | 0.8625 | 0.0014 |

In this study, we aim to evaluate the generation of a mesh from an input point cloud containing 2,500 points. We present qualitative results of this task in the bottom right of Figure  4 and in rows 1–2 of Figure 2.
To quantitatively assess WaLa’s performance, we compare it against both traditional and data-driven techniques, as shown in Table 2. For the traditional approach, we benchmark against Poisson surface reconstruction, which uses heuristic methods to create smooth meshes from point clouds. For Poisson reconstruction, we need normals, so we estimate them using the five nearest neighbors via O3D (Zhou et al., ). After performing Poisson surface reconstruction, we remove vertices whose density values fall below the 20th percentile to avoid spurious faces.
Additionally, we evaluate our method alongside data-driven generative models such as Point-E (Nichol et al., ), MeshAnything (Chen et al., ), and Make-A-Shape (Hui et al., ). For Point-E (Nichol et al., ), we utilize its SDF network to estimate the distance field from the point cloud. We also compare our method with MeshAnything (Chen et al., ), a recent transformer-based neural network designed for meshing point clouds. In this case, we use 2,500 input points and follow their hyperparameters and procedure.
Finally, we compare against Make-A-Shape (Hui et al., ), which also generates meshes conditioned on point clouds and has its model open-sourced.

The quantitative results in Table 2 demonstrate that our method significantly outperforms existing point cloud to mesh generation techniques on both the GSO and MAS validation datasets. These results are despite us not needing normals as in Poisson reconstruction and MeshAnything. Our method can also scale well with data compared to methods like MeshAnything which do not scale well with large face counts. Moreover, our method does not require many surface points to reconstruct a 3D shape, whereas methods like MeshAnything require 8k points (as mentioned in their work) and Point-E requires 4k points.
Qualitatively, our method also outperforms the baselines, as shown in the bottom right of Figure 4, and creates smoother shapes with complex geometry, as demonstrated in rows 1–2 of Figure 2.

#### 4.2.2 Voxel-to-Mesh

**Table 3: Quantitative evaluation on lower resolution voxel data ($16^{3}$ resolution) to mesh generation task. Our method, WaLa, surpasses traditional Nearest neighbour and Trilinear upsampling as well as data-centric method like Make-a-Shape.**
| Method | GSO Dataset | MAS Dataset |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| LFD $\downarrow$ | IoU $\uparrow$ | CD $\downarrow$ | LFD $\downarrow$ | IoU $\uparrow$ | CD $\downarrow$ |  |
| Nearest Neighbour Interpolation | 5158.63 | 0.1773 | 0.0225 | 5401.12 | 0.1724 | 0.0217 |
| Trilinear Interpolation | 4666.85 | 0.1902 | 0.0361 | 4599.97 | 0.1935 | 0.0371 |
| Make-A-Shape (Hui et al., ) | 1913.69 | 0.7682 | 0.0029 | 2566.22 | 0.6631 | 0.0051 |
| WaLa(Ours) | 1544.67 | 0.8285 | 0.0020 | 1874.41 | 0.75739 | 0.0020 |

In this experiment, we evaluate our proposed method, WaLa, against several baseline approaches for generating 3D shapes from low-resolution voxels with a resolution of $16^{3}$. Quantitative results are presented in Table 3, while qualitative comparisons are illustrated in the bottom left of Figure 4 and in rows 3 and 4 of Figure 2.
We evaluate using the GSO and MAS datasets. As detailed in Table 3, WaLa is benchmarked against traditional upsampling techniques (nearest neighbor and trilinear interpolation) and a data-driven approach, Make-A-Shape (Hui et al., ).
For the traditional upsampling baselines, we apply nearest neighbor and trilinear interpolation methods to the $16^{3}$ voxel grids, followed by the marching cubes algorithm (Lorensen & Cline, ) to generate the corresponding meshes. In contrast, the data-driven method utilizes the pre-trained voxel-to-mesh model provided by Make-A-Shape.

The results in Table 3 demonstrate that WaLa consistently outperforms all baseline methods across various metrics and datasets. Notably, our approach achieves significantly lower LFD and CD values, alongside higher IoU scores, compared to both traditional and data-driven techniques.
These quantitative findings suggest that WaLa not only effectively upsamples 3D shapes to higher resolutions but also produces smoother surfaces and higher-quality meshes by accurately filling in missing details. This holds true even for ambiguous shapes (see Figure 2, third row, columns 3–4) and those with disjoint components (see Figure 2, fourth row, columns 3–4). Furthermore, qualitative assessments in Figure 4 corroborate our quantitative results, demonstrating that WaLa reconstructs finer geometric features and more precise details than both traditional interpolation methods and existing data-driven approaches.

#### 4.2.3 Image-to-Mesh

**Table 4: Comparison between different methods on Image-to-3D task (Top) and Multiview-to-3D task (Bottom). Quantitative evaluation shows that our single-view model excels the baselines, achieving the highest IoU and lowest LFD metrics. Our multi-view model further enhances performance by incorporating additional information. RGB 4, Depth 4, and Depth 6 represents conditioning using RGB images from 4 different views, and depth estimates from 4 and 6 views respectively. Inference time is measured on A100 GPU.**
| Method | Inference | GSO Dataset | MAS Val Dataset |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Time$\downarrow$ | LFD $\downarrow$ | IoU $\uparrow$ | CD $\downarrow$ | LFD $\downarrow$ | IoU $\uparrow$ | CD $\downarrow$ |  |
| Point-E (Nichol et al., ) | $\sim$31 Sec | 5018.73 | 0.1948 | 0.02231 | 6181.97 | 0.2154 | 0.03536 |
| Shap-E (Jun & Nichol, ) | $\sim$6 Sec | 3824.48 | 0.3488 | 0.01905 | 4858.92 | 0.2656 | 0.02480 |
| Single-view<br>One-2-3-45 (Liu et al., ) | $\sim$45 Sec | 4397.18 | 0.4159 | 0.04422 | 5094.11 | 0.2900 | 0.04036 |
| OpenLRM (He & Wang, ) | $\sim$5 Sec | 3198.28 | 0.5748 | 0.01303 | 4348.20 | 0.4091 | 0.01668 |
| TripoSR(Tochilkin et al., ) | $\sim$1 Sec | 3750.65 | 0.4524 | 0.01388 | 4551.29 | 0.3521 | 0.03339 |
| InstantMesh(Xu et al., ) | $\sim$10 Sec | 3833.20 | 0.4587 | 0.03275 | 5339.98 | 0.2809 | 0.05730 |
| LGM(Tang et al., ) | $\sim$37 Sec | 4391.68 | 0.3488 | 0.05483 | 5701.92 | 0.2368 | 0.07276 |
| Make-A-Shape(Hui et al., ) | $\sim$2 Sec | 3406.61 | 0.5004 | 0.01748 | 4071.33 | 0.4285 | 0.01851 |
| WaLa (RGB) | $\sim$2.5 Sec | 2509.20 | 0.6154 | 0.02150 | 2920.74 | 0.6056 | 0.01530 |
| WaLa Large (RGB) | $\sim$2.6 Sec | 2473.35 | 0.5984 | 0.02175 | 2562.70 | 0.6610 | 0.00575 |
| WaLa (depth) | $\sim$2.5 Sec | 2172.52 | 0.6927 | 0.01301 | 2544.56 | 0.6358 | 0.01213 |
| WaLa Large (depth) | $\sim$ 2.6 Sec | 2076.50 | 0.7043 | 0.01344 | 2322.75 | 0.6758 | 0.00756 |
| InstantMesh(Xu et al., ) | $\sim$1.5 Sec | 3009.19 | 0.5579 | 0.01560 | 4001.09 | 0.4074 | 0.02855 |
| Multi-view<br>LGM(Tang et al., ) | $\sim$35 Sec | 1772.98 | 0.6842 | 0.00783 | 2712.30 | 0.5418 | 0.00867 |
| Make-A-Shape(Hui et al., ) | $\sim$2 Sec | 1890.85 | 0.7460 | 0.00337 | 2217.25 | 0.6707 | 0.00350 |
| WaLa(RGB 4) | $\sim$2.5 Sec | 1260.64 | 0.8500 | 0.00182 | 1540.22 | 0.8175 | 0.00208 |
| WaLa(Depth 4) | $\sim$2.5 Sec | 1185.39 | 0.87884 | 0.00164 | 1417.40 | 0.83313 | 0.00160 |
| WaLa(Depth 6) | $\sim$4 Sec | 1122.61 | 0.91245 | 0.00125 | 1358.82 | 0.85986 | 0.00129 |

In this section, we compare WaLa with other state-of-the-art image-to-3D generative models, focusing on both single-view and multi-view scenarios. In the single-view setting, our model generates 3D shapes from a single input image or depth map.
For multi-view generation, we utilize four RGB images or four to six depth images along with their corresponding camera parameters. This approach allows us to evaluate the model’s performance under varying conditions, demonstrating the versatility and effectiveness of our generative model in different image-to-3D generation contexts.
Qualitative results for single-view RGB are shown in the top left of Figure 4 and in rows 5–6 of Figure 2. Conversely, qualitative results for multi-view RGB are displayed in the top right of Figure 4 and in rows 7–8 of Figure 2. Additional details and results can be found in the appendix and on our website.
Our quantitative results, which assess both quality and inference time on the GSO and MAS validation datasets, are presented in Table 4, with the Image-to-3D task results at the top and the multiview-to-3D task at the bottom. We attempted to perform an extensive comparison; however, this proved challenging as many methods are not available as open-source implementations or utilize subsets of the GSO dataset for which the sample lists are not publicly available (Zhang et al., ; Siddiqui et al., ; Bensadoun et al., ). Consequently, we chose to use the entire GSO dataset and run open-source models whose code is available for both GSO and MAS.

As demonstrated in Table 4, our method consistently outperforms other 3D generation techniques across both tasks.
For the single image-to-3D task, our base RGB model surpasses all baseline methods by a wide margin on most metrics, except for OpenLRM on the CD metric within the GSO dataset. We believe this exception is primarily due to CD’s sensitivity to rotation, as many generated shapes may not be perfectly aligned with the ground truth. In contrast, the LFD, which is a rotation-invariant metric, clearly shows significant improvement from WaLa as compared to LRM.
Another noteworthy observation is that the WaLa Large model significantly outperforms the WaLa Base model on the MAS test set but does not show a notable improvement on the GSO dataset. This outcome is expected since we trained on the MAS training set, indicating that increasing the number of parameters may not necessarily enhance generalization to the GSO dataset. Additionally, the single-depth model outperforms the RGB base model, which is intuitive as depth maps provide more comprehensive information about the 3D structure.
Finally, it is important to highlight that our model either outperforms or is comparable to most methods in terms of inference time while delivering significantly better quality.
A similar trend is observed in the multi-view image-to-3D task, where our model significantly outperforms baseline methods in quality while maintaining similar or better inference times. Another interesting observation is that increasing the number of depth map images improves performance, which again intuitively makes sense as we have more shape information.

Qualitatively, our method generates 3D shapes with complex geometry (see Figure 2, row 8, column 7-8), multiple disjoint components (see Figure 2, row 6, column 3-4), and intrinsic geometric features (see Figure 2, row 5, column 3-4). Additionally, it produces diverse shapes across various object categories, including organic forms (see Figure 2, row 5, column 5-6) and CAD models (see Figure 2, row 7 column 1-2).
Furthermore, our multi-view model outperforms the single-view model, which is intuitively expected due to the additional information provided by multiple perspectives. Our method also visually surpasses other baselines, as demonstrated in Figure 4, by capturing more details and creating more complex geometries.
We also apply our multi-view approach to text-to-3D generation, as shown in Figure 2, rows 11–12. For these experiments, we utilize the six-view depth model, which achieves the best reconstruction performance. Additionally, we present visual sketch-to-3D results in Figure 2, rows 9–10. The sketch-to-3D models are obtained by fine-tuning the image-to-mesh model with synthetic sketch data. We also fine-tune the image-to-mesh model with single-view depth data and present visual results in Figure 2
, rows 13–14. Further details about these models are provided in the appendix.

## 5 Conclusion

In this work, we introduce Wavelet Latent Diffusion (WaLa), a novel approach to 3D generation that tackles the challenges of high-dimensional data representation and computational efficiency. Our method compresses 3D shapes into a wavelet-based latent space, enabling highly efficient compression while preserving intricate details.
WaLa marks a significant leap forward in 3D shape generation, with our billion-parameter model capable of generating high-quality shapes in just 2–4 seconds, outperforming current state-of-the-art methods. Its versatility allows it to handle diverse input modalities, including single and multi-view images, voxels, point clouds, depth maps, sketches, and text descriptions, making it adaptable to a wide range of 3D modeling tasks.
We believe WaLa sets a new benchmark in 3D generative modeling by combining efficiency, speed, and flexibility. Finally, we release our code and model across multiple modalities to promote further research and support reproducibility within the community.

## 6 Acknowledgement

We are deeply grateful to Shyam Sudhakaran and Martynas Pocius for their generous code release, which provided a valuable foundation for this work. We also wish to thank Hilmar Koch for insightful discussions that guided our approach. Special thanks to Justin Matejka and Kendra Wannamaker for their invaluable support in developing the UI interface and advancing our understanding of the model through hands-on experimentation. Dan Ahren’s significant contributions to PR were instrumental, and we are especially thankful for his efforts. Finally, we extend our sincere appreciation to Anthony Ruto, Tonya Custis, Daron Green, and Mike Haley for their steadfast support and encouragement throughout this project.

## Appendix A Additional Results and Details

For more visual results and detailed information about our model, please visit [https://autodeskailab.github.io/WaLaProject](https://autodeskailab.github.io/WaLaProject). The code is available at [https://github.com/AutodeskAILab/WaLa](https://github.com/AutodeskAILab/WaLa).

## Appendix B Architecture details

In the first stage, we train a convolution-based VQ-VAE using a codebook size of 1024 with a dimension of 4. We downsample the input wavelet tree representation to a $12^{3}\times 4$ latent space. Our generative model operates within this latent space by utilizing the U-ViT architecture Hoogeboom et al. (), incorporating two notable modifications.
Firstly, we do not perform any additional downsampling since our latent space is already quite small. Instead, the model comprises multiple ResNet blocks followed by attention blocks, and then more ResNet blocks at the end, with a skip connection from the initial ResNet block. The attention blocks include both self-attention and cross-attention mechanisms, as described in  (Chen et al., ).
Secondly, we modulate the layer normalization parameters in both the ResNet and attention layers, following the approach detailed in  (Esser et al., ). This tailored architecture enables our generative model to effectively operate within the compact latent space, enhancing both performance and efficiency.

In this section, we describe the details of the various conditions utilized in our model:

- 1.
Point Cloud Model:
During training, we randomly select 2,500 points from the pre-computed point cloud dataset, which was generated from our large-scale dataset comprising 10 million shapes. These points are encoded into feature vectors using the PointNet encoder Qi et al. (). To aggregate these feature vectors into condition latent vectors, we apply attention pooling as described in Lee et al. (). This process converts the individual points into a latent set vector. Finally, we pass this latent set vector through additional Multi-Layer Perceptron (MLP) layers to obtain the final condition latent vectors.
- 2.
Voxel $16^{3}$ Model:
For voxel-based conditions, we employ a ResNet-based convolutional encoder to process the $16^{3}$ voxel grid. After applying multiple ResNet layers, the voxel volume is downsampled to reduce its dimensionality to $8^{3}$. This downsampled volume is then processed with additional ResNet layers, ultimately resulting in the conditional latent vectors. This approach leverages the spatial hierarchy captured by the ResNet architecture to effectively encode volumetric data.
- 3.
Single View Image Model:
Our dataset consists of a predetermined set of views for each object. During training, we randomly select one view from this set. The selected view is then processed by the DINO v2 encoder (Oquab et al., ) to extract feature representations. The encoder’s output serves as the conditional latent vectors, encapsulating the visual information from the single view. It is important to note that we do not train the DINO v2 encoder; instead, we freeze its weights and utilize only the conditional latent vectors.
- 4.
Single View Depth Model:
We begin by selecting a checkpoint from a pre-trained Single View Image Model once it has converged and initialize the depth conditioned generative model using the same architecture described in the single-view section. We then fine-tune the model using pre-computed depth data. Throughout this process, we utilize the DINO v2 encoder (Oquab et al., ) to obtain the conditional latent vectors while keeping the encoder’s weights frozen.
- 5.
Sketch Model:
We initialize the model using the architecture described in the single-view section. After the base model converges, we fine-tune it with sketch data. This fine-tuning process involves training the model on sketch representations to adapt the latent vectors, enabling them to capture the abstract and simplified features characteristic of sketches. As in previous cases, the DINO v2 encoder (Oquab et al., ) remains frozen. Further details about the sketch data are provided in Appendix D.
- 6.
Multi-View Image/Depth Model:
For multi-view scenarios, we select four viewpoints for the multi-view RGB image model and use configurations with four and six views for the multi-view depth model. These views are carefully chosen from pre-defined angles to ensure comprehensive coverage of the object. Each view is independently processed through the DINO v2 encoder (Oquab et al., ), generating a latent vector for each viewpoint. The latent vectors from all views are then concatenated sequentially, forming a final conditional latent representation structured as a sequence of latent vectors with dimensions corresponding to the number of views and the condition vector size. This approach effectively integrates information from multiple perspectives. It’s also important to note that we keep the DINO v2 encoder frozen in this setup.
- 7.
Text to 3D Model: In this case, we use the six-view multi-view depth model for 3D generation and the MVDream model for six-view generation from text. The MVDream model is fine-tuned using six-view depth maps, and details are provided in Appendix E.
- 8.
Uncondtional Model:
For the unconditional model, we use the base U-ViT architecture without any conditioning. We only use time to modulate the normalization parameters of the network. Additionally, we do not apply classifier-free guidance.

## Appendix C Ablation Studies

### C.1 VQ-VAE Adaptive Sampling loss analysis

In this section, we evaluate the importance of adaptive sampling loss by training two autoencoder models for up to 200,000 iterations: one incorporating the adaptive sampling loss and one without it. The results are presented in the first two rows of Table 5
. We use Intersection over Union (IoU) and Mean Squared Error (MSE) to measure the average reconstruction quality across all data points. Additionally, we introduce D-IoU and D-MSE metrics, which assess the average reconstruction performance by weighting each dataset equally. This approach ensures that any data imbalance is appropriately addressed during evaluation.

As shown in the table, even after approximately 200,000 iterations, the model utilizing adaptive sampling loss significantly outperforms the one without it. Specifically, the adaptive sampling loss leads to higher IoU and lower MSE values, indicating more accurate and reliable reconstructions. These results clearly demonstrate the substantial benefits of using adaptive sampling loss in enhancing the performance and robustness of autoencoder models.

### C.2 VQ-VAE Analysis and finetuning Analysis

In this section, we examine the benefits of performing balanced fine-tuning, as described in the main section of the paper. We conduct an ablation study to determine the optimal amount of finetuning data required per dataset to achieve the best results. The results are presented in the rows following the first two in Table 6
, utilizing the metrics described above.

Our observations indicate that even a small amount of fine-tuning data improves the IoU and MSE. Specifically, incorporating as few as 2,500 samples per dataset leads to noticeable enhancements in reconstruction accuracy. However, we found that increasing the finetuning data to 10,000 samples per dataset provides optimal performance. At this level, both IOU and Mean Squared Error (MSE) metrics reach their best values, demonstrating the effectiveness of balanced fine-tuning in enhancing model performance.

Moreover, the D-IoU and D-MSE metrics confirm that using 10,000 samples per dataset effectively mitigates data imbalance to a certain degree. Based on these findings, all subsequent results in this study are based on using 10,000 finetuning samples per dataset. We believe that an interesting area for future work is to improve data curation to further enhance reconstruction accuracy.

**Table 5: Ablation study on adaptive sampling as well finetuning of the VQ-VAE model.**
| Sampling Loss | Amount of finetune data | IOU $\uparrow$ | MSE $\downarrow$ | D-IOU $\uparrow$ | D-MSE $\downarrow$ |
| --- | --- | --- | --- | --- | --- |
| No(^1^11Results for the first two rows are based on 200k iterations.) | - | 0.91597 | 0.00270 | 0.91597 | 0.00270 |
| Yes(^1^11Results for the first two rows are based on 200k iterations.) | - | 0.92619 | 0.00136 | 0.91754 | 0.00229 |
| Yes | - | 0.95479 | 0.00090 | 0.94093 | 0.00169 |
| Yes | 2500 | 0.95966 | 0.00078 | 0.94808 | 0.00149 |
| Yes | 5000 | 0.95873 | 0.00078 | 0.94793 | 0.00149 |
| Yes | 10000 | 0.95979 | 0.00078 | 0.94820 | 0.00148 |
| Yes | 20000 | 0.95707 | 0.00079 | 0.94659 | 0.00150 |

### C.3 Architecture Analysis of generative model

In this section, we conduct an extensive study on the architectural design choices of the generative model. Given the high computational cost of training large-scale generative models, we implement early stopping after 400,000 iterations. The results are presented in Table 6
.
First, we examine the importance of the hidden dimension in the attention layer. It is clearly observed that increasing the dimension enhances performance. A similar trend is noted when additional layers of attention blocks are incorporated. Although the improvement is not pronounced, it is important to mention that these observations are based on only 400,000 iterations.
Finally, we compare the DiT (Peebles & Xie, ) architecture to the U-ViT architecture (Hoogeboom et al., ) and find that U-ViT outperforms DiT. This comparison highlights the superior performance of the U-ViT architecture in our generative model framework.

### C.4 Pre-Quant vs post-quant

In this section, we compare whether it is better to apply the generative model to the grid before or after quantization. We conduct this comparison over 400,000 iterations. The results are shown in Table 6. These results indicate that pre-quantization performs better.

**Table 6: Ablation study on the generative model design choices.**
| Architecture | hidden dim | No. of layers | post or pre | LFD $\downarrow$ | IoU $\uparrow$ | CD $\downarrow$ |
| --- | --- | --- | --- | --- | --- | --- |
| U-VIT | 384 | 32 | pre | 1523.74 | 0.8211 | 0.001544 |
| U-VIT | 768 | 32 | pre | 1618.73 | 0.7966 | 0.001540 |
| U-VIT | 1152 | 8 | pre | 1596.88 | 0.8020 | 0.001561 |
| U-VIT | 1152 | 16 | pre | 1521.81 | 0.8237 | 0.001573 |
| U-VIT | 1152 | 32 | pre | 1507.43 | 0.8199 | 0.001482 |
| DiT | 1152 | 32 | pre | 1527.16 | 0.8145 | 0.001602 |
| U-VIT | 1152 | 32 | post | 1576.07 | 0.8176 | 0.001695 |

## Appendix D Sketch data generation

Figure: Figure 5: The 6 different sketch types. From left to right: Grease Pencil, Canny, HED, HED+potrace, HED+scribble, CLIPaasso, and a depth map for reference. Mesh taken from (Fu et al., ).
Refer to caption: extracted/5995222/figures/sketches.png

We generate sketches using 6 different techniques. In the first technique, we use Blender to perform non-photorealistic rendering of the meshes using a Grease
Pencil Line Art modifier. The modifier is configured to use a line thickness of
2 with a crease threshold of 140°. Since disconnected faces can cause
spurious lines using this method, we automatically merge vertices by distance using a threshold of 1e-6 before rendering. The second technique takes previously
generated depth maps and produces sketches using Canny edge detection. We
apply the Canny edge filter built into imagemagick using a value of 1 for both the blur radius and sigma and a value of 5% for both the low and high threshold. We then clean the output by running it through the
potrace program with the flags --turdsize=10 and --opttolerance=1. The third technique uses
HED (Xie & Tu, ) in its default configuration, also on depth maps. The fourth technique applies potrace on top of default HED, and the fifth applies HED’s ”scribble” filter instead. The sixth and
final technique uses CLIPasso (Vinker et al., ) on previously rendered
color images. We configure CLIPasso to use 16 paths, a width of 0.875, and up to 2,000 iterations, with early stopping if the difference in loss is less than 1e-5.

Figure: Figure 6: The 8 different views for which sketches were generated. Images created using the Grease Pencil technique on a mesh taken from Fu et al. (). The CLIPasso technique was only used on the first, fifth, and sixth views from the left.
Refer to caption: extracted/5995222/figures/sketch-views.png

For the first 5 techniques, sketches are generated from a total of 8 views: the
4 views used for multi-view to 3D, plus views from the front, right side, left side,
and back. For CLIPasso we only generate sketches from the front, right side, and
left back. Additionally, we only generate sketches from a subset of the 10 million shapes which we constructed by taking up to 10,000 shapes from each of the 20 datasets.

During training we augment the sketches by adding random translation, rotation, and scale in order to improve the model’s over-sensitivity to line thickness and padding. We also add random positional noise to the shapes in the SVG drawings
produced by CLIPasso and potrace. Finally, we add a non-affine cage
transformation by dividing the image into 9 squares of equal size. We treat the
four corners of the central square as control points and move each one
independently, warping the image.

## Appendix E Text-to-3D details

The dataset used for this part contains 330,000 objects, comprising 3D-FUTURE, House3D, Toy4K, ShapeNet-v2, and a filtered subset of Objaverse datasets (filtered by (Kant et al., )). We began by generating captions for this dataset using the Internvl 2.0 model (Chen et al., ). For each object, we provided the model with four renderings and created two versions of captions by applying two distinct prompts. These initial captions were then augmented using LLaMA 3.1 (Dubey et al., ) to enhance their diversity and richness.

Next, we fine-tuned the Stable Diffusion model, initializing it with weights from MVDream (Shi et al., ). Utilizing the depth map-text paired data we had collected, we generated six depth maps for each object. To ensure consistency, we identified a uniform cropping box around each object across all depth maps and applied this cropping uniformly to all 6 images. Following the MVDream methodology, we resized the cropped images to 256×256 pixels and employed bfloat16 precision for processing.

During the inference phase, we input text prompts to generate six corresponding depth maps. These depth maps were then used to condition our multi-view depth model, which successfully generated the 3D shape of each object.

## Appendix F Model sizes

Table 7 lists the number of parameters for each of our models.

**Table 7: Number of Parameters for Different Models**
| Method | Number of Parameters |
| --- | --- |
| Autoencoder Model | 12.9 million |
| Uncondition Model | 1.1 billion |
| Single View Model | 956 million |
| Single View Model Large | 1.4 billion |
| Depth View Model | 956 million |
| Depth View Model Large | 1.4 billion |
| Pointcloud Model | 966.7 million |
| Multi View Model (Depth and Image) | 956 million |
| 6 view Depth Model | 898 million |
| Voxel Model | 906.9 million |

## Appendix G Scale and timesteps for different models

Table 8 lists the classifier-free guidance scales and timesteps used in this paper. These parameters were determined through an extensive grid search on the MAS dataset’s validation set. We find that, for most conditions, fewer than 10 timesteps are sufficient, except for the unconditional model. This finding aligns with the results from Make-A-Shape (Hui et al., ), indicating that if the conditioning information is substantial, the diffusion model requires very few timesteps to generate the 3D shape. This is particularly evident in the unconditional setting, where, lacking any shape information hint, the best results are obtained using 1000 timesteps.

**Table 8: Classifier free scale and timestep used in the paper**
| Model | Scale | Timestep |
| --- | --- | --- |
| Voxel | 1.5 | 5 |
| Pointcloud | 1.3 | 8 |
| Single-View RGB | 1.8 | 5 |
| Single-View Depth | 1.8 | 5 |
| Multi-View RGB | 1.3 | 5 |
| Multi-View Depth | 1.3 | 5 |
| 6 Multi-View Depth | 1.5 | 10 |
| Unconditional | - | 1000 |

## Appendix H More Visual Results

Figure: Figure 7: This figure presents more results from the text-to-3D generation task. Each row corresponds to a unique text prompt, with the resulting 3D renderings highlighting the model’s capability to produce detailed and varied shapes from these inputs.
Refer to caption: x5.png

Figure: Figure 8: Here, for each caption, four different 3D variations are displayed. This figure emphasizes the model’s flexibility in generating multiple distinct outputs for the same text description while maintaining thematic consistency.
Refer to caption: x6.png

Figure: Figure 9: Here, for each caption, four different 3D variations are displayed. This figure emphasizes the model’s flexibility in generating multiple distinct outputs for the same text description while maintaining thematic consistency.
Refer to caption: x7.png

In Figure 7, we present additional text-to-3D generation results, showcasing the diversity and quality of outputs produced by our model. Each result highlights the model’s ability to capture various object details and structures based solely on text prompts. In Figure 8 and Figure 9, we illustrate the variety in generation for each caption. For each given caption, we display four different generated outputs, demonstrating the model’s capacity to create diverse yet semantically consistent results based on the same input description. These figures collectively emphasize the robustness and versatility of our approach in generating 3D content from textual inputs.

## Appendix I Contributions

Aditya Sanghi: I am the lead author of this paper and contributed significantly to its development. I was responsible for formulating the main research idea, overseeing the dataset generation, and conducting experiments across various modalities. In addition to leading the research team, I coordinated the integration of different sections, ensured cohesion among contributors, and provided guidance throughout the writing process. I also contributed to the drafting and editing of the manuscript and played a key role in creating the figures and visualizations included in the paper.

Aliasghar Khani: In this paper, I contributed by using vision-language models (VLMs) and large language models (LLMs) to generate captions for over 10 million 3D objects based on their four renderings. I also trained the text-to-multi-view depth generation model utilizing a subset of our dataset. Additionally, I helped create key figures, specifically figures 2, 7, 8, and 9, which visualize and support the paper’s findings.

Pradyumna Reddy: Drafting and refining the paper(Introduction, Related Work, Results), along with assistance with visualizations(Fig 4. Single-View and Multi-View), ensuring clear and concise communication. Running multiple baselines (Tab 1. Poisson Surface Reconstruction. Tab 2. Nearest Neighbour Interpolation and Trilinear Interpolation. Tab 3. Single-View, Multi-View InstantMesh and LGM) for quantitative evaluation with current state of the art models. Designing and implementing the project website to enable sharing of a large number of results for each conditioning variable. Active participation in research discussions, focusing on strategies to improve the model’s resource efficiency.

Arianna Rampini: Implemented fine-tuning for MVDream, later used in text-to-3D applications. Ran baselines (OpenLRM, TripoSR, Point-E) and computed metrics for quantitative evaluation against state-of-the-art models (Tables 2,3,4). Contributed to presenting the work through paper writing (Image to 3D), proof-reading, and figures creation (Fig 2, 4).

Derek Cheung: Researched and implemented techniques for generating synthetic sketches. Performed fine-tuning experiments using sketches; improved lack of robustness in earlier models by adding additional sketch styles and sketch augmentations. Rewrote data processing scripts to perform sketch generation. Demonstrated that fine-tuning on a balanced subset of the 10m dataset was effective for sketch-to-3d; wrote code for creating and managing balanced dataset subsets. Rewrote distributed inference and evaluation scripts.

Kamal Rahimi Malekshan: In this project, I contributed by creating the infrastructure for large-scale training and data processing, ensuring smooth workflows. I also prepared the code for release, resolving key issues related to data preprocessing and post-processing. My work focused on enabling efficient model training and large-scale data handling.

Kanika Madan: Contributed towards running of multiple baselines for comparisons with the relevant state of the art methods (Table 1: MeshAnything with different point cloud resolutions, Make-A-Shape; Table 2: Make-A-Shape). Helped with creating the figures (Fig 1, 2, 4, 7, 8 and 9), as well as helped with paper writing and proof-reading.

Hooman Shayani: Co-managed the project alongside Aditya, contributed to writing the paper, and developed Figure 3. Guided the project throughout its development, including idea generation and strategic planning. Collaborated with Derek on sketch generation and provided valuable feedback on various techniques and methodologies. Furthermore, assisted in testing and validating the models and was heavily involved in the code and model releases.

## Peer Reviews

confidence: 4
contribution: 4
initial_rating: 6
presentation: 3
questions: I have several questions regarding the submission:

1. The model appears to support multiple conditioning inputs. Why doesn’t it support direct text-to-latent generation? Is this not feasible, or was it omitted due to time constraints?
2. The inclusion of SMPL and SMIL in the training dataset is confusing to me. To my knowledge, these are parametric mesh models, and the training scan data for them is not publicly available. How do they contribute to the training data?
3. The results on the anonymous page show a last update on October 10th (according to the Git commit history), which is after the ICLR deadline. Do the authors have evidence that the results were uploaded before the deadline? If the results were updated after the deadline, this would be unfair to other submissions.
soundness: 4
strengths: This paper proposes encoding the wavelet representation into a latent space. While the concepts of the wavelet tree and VQ-VAE latent space are not novel contributions of the paper, the efficiency of the combined solution is compelling. The authors validate the proposed representation by training a generative model, which appears to achieve good results and demonstrates training efficiency (notably, only 1 H100 GPU for training on 10 million shapes—authors, please confirm and include the training time). These aspects represent the strengths of the paper.
summary: This paper presents an approach to encode 3D shapes (TSDF) into a latent space using Wavelet representation via VQ-VAE. Additionally, it trains several latent diffusion models capable of generating latent codes under different conditions, such as single image, multiple images, point cloud, and voxels. The method is trained on a large dataset comprising 10 million 3D shapes collected from 19 different sources. While there are minor weaknesses in the presentation of the paper, the proposed latent wavelet tree representation is efficient and well-suited for 3D shape generation. Therefore, I recommend acceptance of the paper but reserve the right to lower the score if the concerns are not adequately addressed.
weaknesses: After carefully reading the submission and supplementary material, i found following weaknesses:

1. The limitations and broader impact of the proposed method are not discussed in the paper.
2. The lack of hyperlinks for citations makes reading and navigation difficult.
3. Typo: Line 130: "WaLaallows" should be corrected to "Wala allows."
4. Overclaiming in the text-to-3D capability: The method performs text-to-multiview depth generation, followed by multiview depth to 3D reconstruction. It is not a true text-to-3D model.
5. Training details are missing, including the resources and time required for the VQ-VAE model and the training time for the latent generative model.
6. The method cannot generate realistic textures, whereas the baselines in Table 3 are capable of novel view synthesis.

---

confidence: 5
contribution: 1
initial_rating: 3
presentation: 3
questions: The method proposed in this paper is relatively straightforward, as a combination of different existing approaches, so I have no questions.
soundness: 3
strengths: There are two key strengths of this paper:
1. As claimed by the authors, the proposed method is efficient in saving billion-parameters in 3D shape generation.
2. The quantitative and qualitative generation results are good.
summary: The paper proposes a wavelet latent diffusion (WaLa) model for conditional and unconditional 3D shape generation. In general, the proposed method first uses wavelet tree conversion to convert a given shape, which could be of high resolution, into a wavelet tree; then, a wavelet vq-vae is utilized to reconstruct the wavelet tree. This is the first stage during which we can get latent vectors $Z$. In the second stage, a (conditional) diffusion model is adopted to generate the latent vectors $Z$ using a diffusion model. The inference is straightforward, as we first generate a latent vector using the reverse process of a diffusion model and then decode the latent vector to a 3D shape using the trained vq-vae in the first training stage. The experiments are conducted of different conditional (e.g., point cloud, images, sketches, texts, etc) and unconditional 3D shape generation tasks, and achieve the superior performance over the compared methods.
weaknesses: The main concern of this paper is the novelty is very limited.
1. The wavelet tree conversion and the wavelet tree structure are proposed by [1], which is also mentioned in the paper. It is unclear if there are any improvements or modifications made to the wavelet tree proposed in [1] to adapt to the task of this paper.

2. Though parameter-saving is an advantage claimed by the authors, it is well-known that wavelet transformation can be used in signal compression by removing (certain) high-frequency coefficients. So, it weakens the contributions of this paper.

3. The vq-vae is also a well-known variant of the conventional vae, as proposed in [2]. It is also unclear whether any adaption of vq-vae has been proposed to make it more suitable for this 3D generation task.

4. The training stage 2 is nothing more than a well-known DDPM-based generation process. The only difference is not directly generating 3D shapes, but to generate wavelet coefficients. It also shares some similarities (though not exactly the same) as stable diffusion [3].

In short, this paper combines different well-known techniques without any adaptation or modification, so I failed to see any novel things in this paper, though the experimental results are good.

[1] Hui KH, Sanghi A, Rampini A, Malekshan KR, Liu Z, Shayani H, Fu CW. Make-a-shape: a ten-million-scale 3d shape model. InForty-first International Conference on Machine Learning 2024 Jan 20.

[2] Van Den Oord A, Vinyals O. Neural discrete representation learning. Advances in neural information processing systems. 2017;30.

[3] Rombach R, Blattmann A, Lorenz D, Esser P, Ommer B. High-resolution image synthesis with latent diffusion models. InProceedings of the IEEE/CVF conference on computer vision and pattern recognition 2022 (pp. 10684-10695).

---

confidence: 5
contribution: 1
initial_rating: 3
presentation: 3
questions: 1.	Choice of Wavelets: What is the specific rationale behind selecting wavelet-based encodings over other decomposition methods, such as spherical harmonics, for 3D shape generation?
	2.	Parameter Sensitivity: How does the model’s performance vary with different parameters controlling the wavelet transform’s frequency domain decomposition? Have experiments been conducted to assess this sensitivity?
	3.	Reconstruction Fidelity: What measures have been implemented to ensure accurate reconstruction from the compressed wavelet coefficients? Are there scenarios where reconstruction errors become significant, and how are they mitigated?
soundness: 3
strengths: The authors have addressed computational challenges in 3D shape generation by employing wavelet-based latent encodings. This method compresses the model size, contributing to the field by facilitating the training of large-scale generative networks. The focus on 3D generation is relevant, given the demand for high-quality 3D models in various applications. The experimental setup appears reasonable, with models containing approximately one billion parameters and generating shapes within 2–4 seconds. This indicates a practical approach to balancing model complexity and inference time.
summary: The paper introduces Wavelet Latent Diffusion (WaLa), a method for 3D shape generation that employs wavelet-based latent encodings. By compressing a 256³ signed distance field into a 12³ × 4 latent grid, the authors claim a 2,427× compression ratio with minimal detail loss. This compression purportedly facilitates the training of large-scale generative networks, enabling the generation of high-quality 3D shapes at 256³ resolution. The models, both conditional and unconditional, contain approximately one billion parameters and are reported to generate shapes within 2–4 seconds. The authors intend to open-source the code and model weights upon acceptance.
weaknesses: •	Insufficient Justification for Wavelet Choice: The paper does not provide a compelling rationale for selecting wavelet-based encodings over other decomposition methods, such as spherical harmonics, which are commonly used in 3D shape representation.
	•	Lack of Parameter Sensitivity Analysis: There is no discussion on how sensitive the model’s performance is to the parameters controlling the wavelet transform’s frequency domain decomposition. This omission raises concerns about the robustness and generalizability of the approach.
	•	Reconstruction Accuracy Concerns: The paper does not thoroughly address potential challenges in achieving accurate reconstruction from the compressed wavelet coefficients. Without empirical evaluations demonstrating reconstruction fidelity, the effectiveness of the compression technique remains uncertain.

---

confidence: 5
contribution: 2
initial_rating: 3
presentation: 3
questions: I have described the main questions, suggestions and concerns in the weakness section. I am certainly open to raising my rating if, especially, the main concern is addressed and the authors (and possibly other reviewers) can convince me of the contribution to the broad ICLR community. 

Additionally, I have a few short questions:
(1) Why is WaLa depth 4 and RGB 4 of different speed in Table 3? If I understood it correctly, those models should be the same architecture wise.
(2) What is the reason for depth metrics being higher than the RGB ones? 
(3) How is the ground truth data generated, i.e. the actual TSDFs from the meshes and how compute intense is this?
(4) How does your VAE fine-tuning strategy using 10k samples of each dataset actually help? If you randomly sample from each dataset, then the overall data distribution will be the same, right?

There are spaces missing on page 3 line 130, page 4 line 164, page 4 line 187 and a capital letter is used on page 8 line 425.

___

***After rebuttal*** 

I will keep my initial score since authors did not reply.
soundness: 4
strengths: In general, the paper is well written, with a clear structure and concise visualizations. The main originality and contribution comes from the combination of the existing wavelet-tree representation with a VQ-VAE. This is a very logical step following existing approaches in diffusion-based generative literature. The VQ-VAE is trained similarly to [1] using an adaptive sampling strategy and allows the LDM to focus solely on the general shape quality and thus improving overall performance. The experimental section clearly confirms the overall performance boost in various tasks.
summary: This paper introduces an extension to Make-a-Shape [1] to reduce computational cost and improve overall generative performance by incorporating a vector-quantized variational autoencoder (VQ-VAE). The pipeline consists of first converting a truncated signed distance function to a wavelet-tree representation, autoencoding this representation with a VQ-VAE that emits a low-dimensional latent grid in the bottleneck and training a latent diffusion model (LDM) in this latent space. As shown in the original LDM paper [2], this approach enables larger diffusion models, higher quality and faster inference. The authors evaluate their model on a variety of conditional generative tasks such as point cloud to mesh, single and multi-view RGB images to mesh, sketches to mesh or text to mesh. Furthermore, experiments show superior results to various previous methods, both qualitatively and quantitatively. 

[1] Hui, Ka-Hei, et al. "Make-a-shape: a ten-million-scale 3d shape model." Forty-first International Conference on Machine Learning. 2024.
[2] Rombach, Robin, et al. "High-resolution image synthesis with latent diffusion models." Proceedings of the IEEE/CVF conference on computer vision and pattern recognition. 2022.
weaknesses: I have several concerns that are relevant for my overall rating, but the lack of contribution is certainly the most important one and is the main reason for my overall negative rating. The entire technical aspects of wavelet-based diffusion models have been explored in previous work [1, 3]. Scaling and improving diffusion models and lowering computational cost by combining VAEs and latent diffusion models has been studied extensively [2, 4, 5, 6, 7, 8, 9]. Could you clarify what the novelty is, besides improved performance and how it differs from existing approaches, besides using a VAE? While I really acknowledge and appreciate the authors' effort in implementing and training the entire model, it reads more as an extension of [1] and seems too little of a contribution for ICLR, but rather a very good fit for a journal extension. This should really not be understood as a critique of the general paper's quality, but rather about its suitability to this specific conference. Nevertheless, I am happy to be convinced of the contrary and ready to raise my rating if the authors and other reviewers provide legit reasons and arguments. 
Additionally, while the experimental section is quite elaborated, it is missing basic comparisons: (1) how much improves the latent diffusion model over simply using the VQ-VAE in the unconditional setting; (2) only conditional tasks are evaluated quantitatively, but unconditional comparisons are completely missing, in particular metrics like 1-nearest neighbor accuracy (1-NNA), maximum mean distance (MMD), coverage (COV) and FID from randomly rendered images. Adding these unconditional experiments in a revised version would strengthen the evaluation and allow for comparison with existing unconditional 3D generative models. 

Lastly, there are some minor weaknesses that should be easy to resolve. They can be viewed as (subjective) recommendations to (possibly) improve paper quality.
(1) The evaluation datasets are not well documented. It is not clear how many samples there are in total for each of them and how they relate to the extensive training set, e.g. how diverse are they? Could you provide the exact numbers and describe how these datasets (e.g. the categories) relate to the training set.
(2) The title and abstract suggest that the model uses a billion parameters, one page 6, line 310 it is billions of parameters but I cannot find an actual number of parameters and the actual model architecture neither in the main paper nor in the supplementary material. 
(3) The section of the VQ-VAE seems to be too extensive, while the section on the wavelet-tree is definitely underrepresented and should be explained in more detail.

[3] Hui, Ka-Hei, et al. "Neural wavelet-domain diffusion for 3d shape generation." SIGGRAPH Asia 2022 Conference Papers. 2022.
[4] Vahdat, Arash, Karsten Kreis, and Jan Kautz. "Score-based generative modeling in latent space." Advances in neural information processing systems 34 (2021): 11287-11302.
[5] Sinha, Abhishek, et al. "D2c: Diffusion-decoding models for few-shot conditional generation." Advances in Neural Information Processing Systems 34 (2021): 12533-12548.
[6] Vahdat, Arash, et al. "Lion: Latent point diffusion models for 3d shape generation." Advances in Neural Information Processing Systems 35 (2022): 10021-10039.
[7] Gao, Ruiqi, et al. "Cat3d: Create anything in 3d with multi-view diffusion models." arXiv preprint arXiv:2405.10314 (2024).
[8] Zhang, Bowen, et al. "Compress3D: a compressed latent space for 3D generation from a single image." European Conference on Computer Vision. Springer, Cham, 2025.
[9] Gupta, Anchit, et al. "3dgen: Triplane latent diffusion for textured mesh generation." arXiv preprint arXiv:2303.05371 (2023).