Flex3D: Feed-Forward 3D Generation with Flexible Reconstruction Model and Input View Curation

## Abstract

Abstract Generating high-quality 3D content from text, single images, or sparse view images remains a challenging task with broad applications.
Existing methods typically employ multi-view diffusion models to synthesize multi-view images, followed by a feed-forward process for 3D reconstruction.
However, these approaches are often constrained by a small and fixed number of input views, limiting their ability to capture diverse viewpoints and, even worse, leading to suboptimal generation results if the synthesized views are of poor quality.
To address these limitations, we propose Flex3D, a novel two-stage framework capable of leveraging an arbitrary number of high-quality input views.
The first stage consists of a candidate view generation and curation pipeline.
We employ a fine-tuned multi-view image diffusion model and a video diffusion model to generate a pool of candidate views, enabling a rich representation of the target 3D object.
Subsequently, a view selection pipeline filters these views based on quality and consistency, ensuring that only the high-quality and reliable views are used for reconstruction.
In the second stage, the curated views are fed into a Flexible Reconstruction Model (FlexRM), built upon a transformer architecture that can effectively process an arbitrary number of inputs.
FlexRM directly outputs 3D Gaussian points leveraging a tri-plane representation, enabling efficient and detailed 3D generation.
Through extensive exploration of design and training strategies, we optimize FlexRM to achieve superior performance in both reconstruction and generation tasks.
Our results demonstrate that Flex3D achieves state-of-the-art performance, with a user study winning rate of over 92% in 3D generation tasks when compared to several of the latest feed-forward 3D generative models. See project page for more immersive 3D results.

## 1 Introduction

Fast generation of high-quality 3D contents is becoming increasingly important for video games development (Hao et al., ; Sun et al., ), augmented, virtual, and mixed reality (Li et al., ), robotics (Nasiriany et al., ) and many other applications.
Recent advances in computer vision and graphics (Mildenhall et al., ; Kerbl et al., ) and deep learning (Dosovitskiy, ; Caron et al., ; Oquab et al., ), combined with the availability of large datasets of 3D objects (Deitke et al., ; ; Yu et al., ; Chang et al., ), have made it possible to learn neural networks that can generate 3D objects from text, single images or a sparse set of views, and to do so in an efficient, feed-forward manner.

A particularly successful family of 3D generators are the ones based on sparse-views reconstruction (Xu et al., ; Siddiqui et al., ; Li et al., ; Zhang et al., ; Tang et al., ; Xu et al., ; Xie et al., ; Wang et al., ).
Compared to single-image reconstructors, multi-view reconstruction models generally produce better 3D assets.
This advantage arises because the multi-view images implicitly capture the object geometry much better, substantially simplifying the reconstruction problem.
However, to generate a 3D object from text or a single image, one must first synthesize several views of the objects, for example by means of a multi-view diffusion model.
These multi-view diffusion models often generate inaccurate and inconsistent views, which are difficult for the reconstruction network to reconcile, and can thus affect the overall quality of the final 3D output (Tang et al., ).

This paper thus focuses on the problem of generating a high-quality set of different views of an object, with the goal of improving the quality of the final 3D object reconstruction.
We build on a simple observation: the quality of the 3D reconstruction improves as the quality and quantity of the input views increases (Han et al., ).
Hence, instead of relying on a fixed, limited set of views generated by potentially unreliable multi-view diffusion models, we suggest to generate a pool of candidate views and then automatically select the best ones to use for reconstruction.

Based on this idea, we introduce a new framework, *Flex3D*, comprising a new multi-view generation strategy as well as a new flexible feed-forward reconstruction model.

First, we propose a mechanism to generate a large and diverse set of views.
We do this by training two diffusion models, one that generates novel views at different azimuth angles and the other at different elevation angles.
The models are designed to make the views as consistent as possible.
Second, we propose a view selection process that uses a generation quality classifier and a feature matching network to measure the consistency of the different views.
The result of this selection is a good number of high-quality views, which help to improve the quality of the final 3D reconstruction.

Differently from many prior works, then, we need to reconstruct the 3D object from a variable number of views which depends on what the selection process returns.
Hence, we require a reconstruction model that
(1) can ingest a varying numbers of input views and different viewing angles;
(2) is memory and speed efficiency to handle a large number of input views; and
(3) can output a full, high-quality 3D reconstruction of the object, regardless of the number and pose of input views.

To this end, we introduce *Flexible Reconstruction Model* (FlexRM).
FlexRM starts from the established Instant3D architecture (Li et al., ) and adds a stronger camera conditioning mechanism to address the first requirement (1).
It also introduces a simple but effective way of combining the Instant3D tri-plane representation with 3D Gaussian Splatting, meeting requirements (2) and (3).
Specifically, FlexRM learns a Multi-Layer Perceptron (MLP) to decode the tri-plane features into the parameters of 3D Gaussians used to represent the object.
We also simplify the process of learning this MLP, thus leading to notable performance improvements, by pre-training parts of it, where we initialize the color and opacity parts using an off-the-shelf NeRF (Mildenhall et al., ) MLP.
For the remaining Gaussian parameters, we learn rotation and scale in a conventional manner while learning position offsets which are combined with the tri-plane feature sampling locations.

While our view selection pipeline identifies the best views for reconstruction, it still does not eliminate all multi-view inconsistencies.
To mitigate the impact of the minor inaccuracies that remain, FlexRM employs a novel training strategy.
Although our training dataset consists of perfectly rendered images, we simulate imperfections in the input views by leveraging the output of FlexRM itself.
Specifically, we take FlexRM’s reconstructed 3D Gaussians, add noise to them, and generate new noisy views of the object based on these noisy Gaussians.
Compared to directly manipulating the views, this approach allows us to inject more expressive and representative types of noise, as shown in fig. 3.
The noisy views are then combined with clean rendered views and fed as input to the 3D reconstructor, with the goal of producing clean, noise-free representations of the 3D object.
This approach enables the model to learn how to handle imperfect inputs.

We benchmark our method against state-of-the-art feed-forward models in 3D generation and 3D reconstruction tasks, evaluating performance through a user study and various automated metrics. We achieve the best results in reconstruction tasks across all settings (single-view, four-view, and more-view), as well as in generation tasks. We also conduct a thorough ablation study to assess the impact of our design choices.

In summary, this paper makes the following key contributions:
(1) We introduce a new generation pipeline that starts by generating a pool of 2D views of an object and then selects the best ones for 3D reconstruction.
(2) We propose FlexRM, a 3D reconstruction network that can efficiently process an arbitrary number of input views with varying viewpoints, obtaining a complete reconstruction of the 3D object which can then be converted to a mixture of 3D Gaussians.
(3) We further introduce a new training strategy to enhance the performance and robustness of the 3D reconstructor by simulating imperfections in the input views during training, leveraging the model’s own outputs and injecting noise into the Gaussians.

## 2 Related work

### 2.1 Multi-view Generation

Generating novel views from a single image or text without learning a 3D representation is a highly ill-posed and challenging task.
With the development of image and video diffusion models, this task has become easier to address, as solutions can be built upon these pre-trained models.

Zero123 (Liu et al., ) first proposed using multi-view data to fine-tune an image diffusion model for generating novel views from a single view, conditioned on camera parameters.
Following this approach, subsequent works (Li et al., ; Shi et al., ; Tang et al., ; Liu et al., ; Long et al., ; Wang & Shi, ; Woo et al., ; Yang et al., ; Ye et al., ; Zhao et al., ; Zheng & Vedaldi, ; Tang et al., ) largely focused on generating multiple views simultaneously to ensure 3D consistency.

With the availability of powerful video diffusion models, recent works (Kwak et al., ; Voleti et al., ; Melas-Kyriazi et al., ; Li et al., ; Han et al., ; Gao et al., ; Zuo et al., ; Yang et al., ) have adopted them to improve multi-view generation.
However, none of these models can reliably generate a large number of perfectly consistent views.
Furthermore, even with camera conditioning, models like SV3D (Voleti et al., ) perform poorly when the specified elevation angle deviates from zero.
This justify our approach of selecting the best views from a pool of generated views.

Figure: Figure 2: Flex3D comprises two stages: (1) candidate view generation and selection, and (2) 3D reconstruction using FlexRM. In the first stage, an input image or textual prompt drives the generation of a diverse set of candidate views through fine-tuned multi-view and video diffusion models. These views are subsequently filtered based on quality and consistency using a view selection mechanism. The second stage leverages the selected high-quality views, feeding them to FlexRM which reconstruct the 3D object using a tri-plane representation decoded into 3D Gaussians.
Refer to caption: x2.png

### 2.2 Feed-forward 3D Reconstruction and Generation

Recent advances in 3D reconstruction and generation have focused on training feed-forward models that directly output 3D representations without requiring further optimization (Yu et al., ; Erkoç et al., ; Szymanowicz et al., ; Ren et al., ; Lorraine et al., ; Xu et al., ; Tochilkin et al., ; Zhang et al., ; Jiang et al., ; Han et al., ).
These feed-forward models offer significant advantages in both reconstruction quality and inference speed.

A representative series of work is LRM (Hong et al., ), which learns to generate a tri-plane NeRF (Chan et al., ) representation using a transformer network.
This approach can receive multiple types of inputs, including single images, text (Xu et al., ), posed sparse-view images (Li et al., ), and unposed sparse-view images (Wang et al., ).
Further works (Wei et al., ; Siddiqui et al., ; Xu et al., ; Wang et al., ; Boss et al., ) focused on improving the geometric quality of generated 3D assets.
Some (Zou et al., ) proposed to combine the tri-plane representation with 3D Gaussian Splatting for more efficient rendering.
They suggest using an additional point cloud network to determine the 3D Gaussian position to overcome the tendency of 3D Gaussian to get stuck in local optima.

Another representative series of work (Tang et al., ; Xu et al., ; Zhang et al., ) generates 3D Gaussian points directly through per-pixel aligned Plücker ray embedding and predicts the depth for each pixel (Szymanowicz et al., ), which can then be converted to 3D Gaussian locations.
However, such approaches requires the input views to cover a large visible range of the 3D object.
Building an intermediate 3D feature representation to regress 3D Gaussian points is also possible (Chen et al., ; Zhang et al., ), but these methods still require sparse-view images as input and typically prefer a fixed number of views with fixed viewing angles.
However, in 3D generation tasks where sparse input views are generated through a multi-view diffusion model and are not always of high quality, such sparse-view reconstructors tend to produce suboptimal results.

This paper introduces a flexible 3D reconstruction model that combines the strengths of the approaches above.
Our tri-plane-based model efficiently generates high-quality 3D Gaussian points directly, without needing additional modules.
It also accommodates a variable number of input views, enabling integration with our view selection pipeline for high-quality 3D generation.

## 3 Method

We illustrate our method in fig. 2. We begin by presenting our approach for generating a pool of candidate views and the subsequent selection process in section 3.1.
We then describe the design of the FlexRM in section 3.2.
Finally, we outline our training strategy that simulates imperfect input views in section 3.3.

### 3.1 Candidate View Generation and Selection

Here we describe how a pool of candidate views is generated from a single image or text and then filtered for quality and consistency before performing 3D reconstruction.

#### Multi-view generation at varying elevations.

Our image/text-to-multi-view-images generator module generates four views of the 3D object from four elevation degrees (-18°, 6°, 18°, and 30°)
We utilize the Emu model (Dai et al., ), which is pre-trained on a massive dataset of billions of text-image pairs, as our base model.
Following prior works (Shi et al., ; Li et al., ; Siddiqui et al., ), we fine-tune this model on approximately 130,000 rendered multi-view images.
This fine-tuning process enables the model to predict a 2$\times$2 grid of four consistent images, each corresponding to one of the specified elevation angles.

#### Multi-view generation at varying azimuths.

After generating four views at varying elevations, we employ a fine-tuned Emu video model (Girdhar et al., ; Melas-Kyriazi et al., ; Han et al., ) to generate a video with 16 views spanning a full 360° azimuth range.
This model is fine-tuned on a dataset encompassing a wide spectrum of elevation angles, enabling it to generate consistent, high-quality views from diverse inputs with varying elevations.
We generate the multi-view videos starting from the input view at 6° elevation, which usually results in representative views for the subsequent reconstruction process.

#### View selection.

As the two multi-view diffusion models are focused on different aspects (elevation and azimuth) of novel view generation, there are minimal conflicts in the generated views between them.
Even so, and despite efforts to improve the quality of the outputs, not all generated views are entirely consistent.
Certain views, particularly those from challenging angles like the back, may exhibit suboptimal generation quality, and there can be inconsistencies between different generated views.
Including such flawed views as input for 3D reconstruction can significantly degrade the quality of the final 3D asset.
Therefore, we introduce a mechanism to filtering poor-quality views.
This is done via a novel view selection pipeline which consists of two steps:

(1) Back View Quality Assessment:
We employ a multi-view video quality classifier trained to assess the overall quality of generated videos, with particular emphasis on the quality of the back view. This classifier utilized DINO (Oquab et al., ) to extract features from the front view and back view of the multi-view video, and subsequently trained a Support Vector Machine (SVM) to classify video quality based on the combined DINO features. The training data consisted of 2000 manually labeled “good” and “bad” Emu-generated video samples.

We apply the quality classifier to the multi-view video to determine whether the back view exhibits reasonable generation quality.

(2) Multi-View Consistency Verification:
If the back view quality is deemed acceptable, we designate both the back and front views as initial query views.
The front view typically possesses the highest visual quality, as it is directly based on the input provided to the fine-tuned EMU video diffusion model.
Conversely, if the back view quality is inadequate, only the front view serves as the initial query view.
We utilize the Efficient LoFTR (Wang et al., ) to match features between all 20 generated views and the selected query views. Views with matching point counts exceeding the mean minus 60% of the standard deviation are added to the selected results. This step effectively gathers high-quality side views and views at different poses that demonstrate strong consistency with the initial query views.

The whole process of view selection can be done in less than a second with a single A100 GPU.

### 3.2 Flexible Reconstruction Model (FlexRM)

As outlined in the introduction, FlexRM aims to fulfill the following requirements:
(1) adaptability to varying numbers of input views and their corresponding viewing angles,
(2) memory and speed efficiency, and
(3) the ability to infer a full 3D reconstruction of the object independently of how many and which views are available.
We follow a minimalist design philosophy and strive to minimize modifications to Instant3D, enabling easy reuse of weights from architectures like Instant3D, and simplifying implementation.

#### Stronger camera conditioning.

Handling varying numbers of input views with viewing angles necessitates providing camera information to the network.
In Instant3D, each view’s camera information, including its extrinsic and intrinsic parameters, is represented as a 20-dimensional vector.
This vector is then passed through a camera embedder to produce usually a 1024-dimensional camera feature, which is subsequently injected into the DINO (Oquab et al., ) image encoder network (responsible for extracting image features for each view) using an AdaIN (Huang & Belongie, ) block.
The image encoder’s final output comprises a set of pose-aware image tokens, which has 1024 768-dimensional tokens for every 512$\times$512 resolution input view. These per-view tokens are concatenated to form the feature descriptors for input views.

Our aim is to ensure that the DINO-extracted tokens are not only camera-aware, but also explicitly incorporate learnable camera information into the final feature descriptors.
To achieve this, we set the output dimension of the camera embedder to 768, enabling it to match the dimension of the pose-aware image tokens and be appended to them, resulting in 1025 (1024 image tokens + 1 camera token) 768-dimensional tokens overall.
This simple way of attaching explicit camera information enhances the network’s camera awareness, strengthening its performance in complex scenarios where a large number of input views is provided.

#### Bridging tri-planes and 3D Gaussian Splatting.

For rendering speed and memory efficiency, we opt to use 3D Gaussian Splatting (3DGS) (Kerbl et al., ) to represent the 3D object.
However, Instant3D uses a tri-plane NeRF representation instead.
To bridge these two, we predict a set of 3D Gaussian from the tri-plane features via an MLP.
Because 3DGS is notoriously sensitive to the initial Gaussian parameters, we carefully initialize both the MLP predictor and the tri-plane transformer network with an off-the-shelf tri-plane NeRF network.

A tri-plane is a compact representation of a volumetric function $[-1,1]^{3}\rightarrow\mathbb{R}^{d}$ mapping points $\mathbf{p}\in[-1,1]^{3}$ to feature vectors $f(\mathbf{p})\in\mathbb{R}^{d}$.
Starting from an initial position $\mathbf{p}_{0}$, the model first reads off the corresponding tri-plane feature $f(\mathbf{p}_{0})$, and then feeds the latter into an MLP to predict the parameters of a corresponding 3D Gaussian, namely, its position, color, opacity, rotation, and scaling.
To obtain a mixture of such Gaussians, we simply start from a set of initial positions $\mathbf{p}_{0}$ and apply the MLP at each location. We use a 100 $\times$ 100 $\times$ 100 grid to sample the initial positions, resulting in the prediction of 1 million Gaussians.

The position of the 3D Gaussian is expressed as
$\mathbf{p}=\alpha\mathbf{p}_{0}+(1-\alpha)\delta\mathbf{p}=\alpha\mathbf{p}_{0
}+(1-\alpha)f(\mathbf{p}_{0})$
where $\delta\mathbf{p}$ is a a positional offset output by the MLP and $\alpha=3/4$.
These positional offsets $\delta\mathbf{p}$ are constrained to the range of $[-1,1]$ through the application of the tanh activation function.
This approach, akin to residual learning, facilitates the optimization process.
The multipliers ensure that $\mathbf{p}$ remains within the same range as $\mathbf{p}_{0}$, which prevents Gaussian points from moving beyond the visible boundaries, which would result in their projection falling outside the 2D image plane and consequently providing no gradients for optimization.
Furthermore, since $\alpha<1$, this expression biases Gaussians to shift towards the center of the tri-plane grid, where the object is usually located.

The color and opacity of the Gaussian are output by the same MLP that, in Instant3D, outputs the color and opacity of their NeRF representation.
These two parameters need no conversion as color and opacity in NeRF and 3DGS are similar in functionality.
Finally, the part of the MLP that predicts the Gaussian rotation and scaling parameters are learned from scratch.

#### Data.

Our training dataset comprises multi-view dense renders from an internal dataset analogous to Objaverse.
Specifically, for each object, we render 512$\times$512 resolution images from 256 viewpoints, uniformly distributed across 16 azimuth and 16 elevation angles. This process yields approximately 700,000 rendered objects, with 140,000 classified as high-quality.
Furthermore, we leverage the Emu-video synthetic dataset (Han et al., ), which consists of 2.7 million synthetic multi-view videos. Each video comprises 16 frames capturing a 360-degree azimuth at a fixed elevation angle.

#### Two-stage training.

Initially, we pre-train FlexRM using a NeRF MLP architecture.
This stage employs the Emu-video synthetic data, where we randomly select 1 to 16 input images (256 $\times$ 256 resolution) and render 4 views with fixed rendering resolution of 256 $\times$ 256 and patch resolution of 128 $\times$ 128 for supervision (L2, LPIPS (Zhang et al., ), and opacity).
The pre-training phase aims to provide a good initialization for the subsequent GS MLP training and is conducted for 10 epochs, requiring 2 days on 64 A100 GPUs.

For the second GS training stage, we utilize the 700,000 dense renders.
A random number (between 1 and 32) of input images (512$\times$512 resolution) are fed into FlexRM, and we render 4 novel views (512$\times$512 resolution) to compute losses.
Given that our dense renders encompass images with diverse elevation angles, we implement weighted sampling for both input and rendered images.
This assigns higher selection probabilities to images with elevation angles closer to zero.
The training process spans 20 epochs and takes 4 days on 128 A100 GPUs.

FlexRM generates 1M 3DGS points in under 0.5 second and renders in real time with a single A100 GPU. Increasing the number of input images has only slight impact on speed and memory usage.

More details on implementation and training of FlexRM are presented in the Appendix A.

Figure: Figure 3: Imperfect Input View Simulation Results. We simulate different kinds of imperfect input views by feeding FlexRM’s output back as input and manipulating 3D Gaussian parameters.
Refer to caption: x3.png

### 3.3 Imperfect input view simulation

Even after input view selection, these views may still contain minor imperfections.
To enhance FlexRM’s suitability for generation tasks, we require it to be robust to such imperfections while maintaining high-quality 3D outputs.
We achieve this robustness by simulating imperfect inputs during a fine-tuning stage.

This necessitates simulating a wide variety of imperfections efficiently.
Simply adding noise in image space
makes it difficult to simulate imperfections arising from geometric distortions.
Instead, we propose a three-step process:
(1) First, we perform inference using FlexRM with a small random number of rendered images (between 1 and 8) as inputs to generate another random number of images (between 1 and 32) for subsequent use as inputs.
(2) Next, we use these generated images to replace the rendered images at the same viewing angles with a 50% probability, forming a new input set. This replacement probability is based on the observation that multi-view diffusion-generated images typically exhibit inconsistencies and imperfections non-uniformly. Additionally, this approach encourages the reconstructor to focus more on high-quality input views.
(3) Finally, we re-run FlexRM with gradients enabled, using the new input set as inputs and supervising it with novel view rendering losses, while
utilizing perfectly rendered views as ground truth.
This fine-tuning process enables FlexRM to learn to tolerate minor imperfections in input views and still produce high-quality 3D reconstructions.

While FlexRM’s outputs naturally contain small imperfections, we also introduce random perturbations to FlexRM’s generated 3D Gaussian points during step (1) to simulate a wider range of imperfect inputs and promote greater diversity.
We sample a randomly sized small cube from the large tri-plane cube and add noise with varying intensities to the 3D Gaussian parameters, excluding rotation.
For example, adding noise to positions can simulate part-level 3D inconsistencies, while adding noise to color parameters can simulate color distortions.
Adding noise to opacity results in a speckled or streaky appearance, while adding noise to scale leads to a blurring effect.
Figure 3 illustrates these effects.
During training, each effect is randomly used with a probability of 0.2.
This combines them for greater diversity. Please check Appendix A for more details.

## 4 Experiments

We evaluate Flex3D on the 3D generation (section 4.1) and 3D reconstruction (section 4.2) tasks, comparing it to state-of-the-art methods and ablating various design choices (section 4.3).

### 4.1 3D Generation

Figure: Figure 4: Qualitative Results of Text-to-3D Generation. Flex3D demonstrates higher generation quality with strong 3D consistency, outperforming all other methods.
Refer to caption: x4.png

**Table 1: Comparisons on 3D Generation Task. Flex3D achieves the highest scores for both CLIP text similarity and VideoCLIP text similarity, exhibiting better performance in text alignment. For generation quality, we conduct a user study to assess it, and the winning rate of Flex3D is always greater than 92%, demonstrating its strong generation performance.**
| Method | CLIP text similarity$\uparrow$ | VideoCLIP text similarity$\uparrow$ | Flex3D win rate |
| --- | --- | --- | --- |
| OpenLRM | 0.243 | 0.229 | 100 % |
| VFusion3D | 0.265 | 0.238 | 95.0 % |
| LGM | 0.266 | 0.240 | 97.5 % |
| InstantMesh | 0.272 | 0.236 | 95.0 % |
| GRM | 0.268 | 0.253 | 92.5 % |
| Flex3D | 0.277 | 0.255 | - |

We leverage 404 deduplicated prompts from DreamFusion (Poole et al., ) to conduct an experiment on text-to-3D or single-image-to-3D generation.
We compare Flex3D to OpenLRM (He & Wang, ; Hong et al., ), VFusion3D (Han et al., ), LGM (Tang et al., ), InstantMesh (Xu et al., ), and GRM (Xu et al., ).
For GRM, we utilize its provided Instant3D’s multi-view diffusion model to generate input multi-view images, and for InstantMesh, we employ the default Zero123++ (Shi et al., ) for text-to-input multi-view image conversion.

We present qualitative results in fig. 4.
Our model demonstrates strong generation capabilities with good global 3D consistency and detailed high-quality textures.
Quantitative results are presented in table 1, where Flex3D outperforms all baselines, showing high alignment in text prompt and generated content.

To further evaluate the overall quality of the generated content, we conducted a user study.
Participants were presented with pairs of 360° rendered videos—one generated by Flex3D and one by a baseline model—and asked to select their preferred video.
We randomly selected 40 prompts for evaluation. The corresponding 40 pairs of generated videos were then independently evaluated by five users, with each user assessing all 40 pairs. For each pair, we collect five results, and the majority preference was recorded as a win rate for Flex3D.

**Table 2: Reconstruction Performance on the GSO Dataset. FlexRM consistently outperforms other baselines, where it achieves the best results across different input view settings. Increasing the number of input views for FlexRM generally leads to improved reconstruction quality.**
| Method | Num of input views | PSNR$\uparrow$ | SSIM$\uparrow$ | LPIPS$\downarrow$ | CLIP image sim$\uparrow$ |
| --- | --- | --- | --- | --- | --- |
| OpenLRM | 1 | 15.83 | 0.821 | 0.209 | 0.602 |
| VFusion3D | 1 | 19.10 | 0.827 | 0.158 | 0.759 |
| FlexRM | 1 | 21.21 | 0.862 | 0.125 | 0.832 |
| InstantMesh | 4 | 21.33 | 0.859 | 0.133 | 0.809 |
| GRM | 4 | 25.03 | 0.899 | 0.102 | 0.869 |
| FlexRM | 4 | 25.55 | 0.894 | 0.074 | 0.893 |
| FlexRM | 8 | 26.33 | 0.897 | 0.069 | 0.906 |
| FlexRM | 16 | 26.51 | 0.902 | 0.068 | 0.911 |

Results are also shown in table 1, where a significant number of votes goes to our method for its high quality, regardless of the baselines used for comparison. This shows that our method clearly generates better 3D assets.

### 4.2 3D Reconstruction

We utilize the Google Scanned Objects (GSO) dataset (Downs et al., ) for evaluation.
From this dataset, we use 947 objects excluding some shoes that are so similar to be redundant.
Each object is rendered at 512$\times$512 resolution from 64 different viewpoints, which are generated using four elevation settings: -30°, 10°, 30°, and 45°.
The azimuth angles are uniformly sampled between 0° and 360°.

In table 2 we report the performance of FlexRM on the GSO reconstruction task, using varying numbers of input views, namely 1, 4, 8, and 16.
We compare our results to several baseline methods, including single-view reconstruction models (LRM (Hong et al., ; He & Wang, ), VFusion3D (Han et al., )) and sparse-view reconstruction models (InstantMesh (Xu et al., ), GRM (Xu et al., )). For the single-view setting, we use the input view at 0° azimuth and 10° elevation as input.
For the 4-view setting, we use views at 0°, 90°, 270°, and 360° azimuth degrees, all at 10° elevation.
For other numbers of views, we heuristically select more views as input.
The remaining views are used to compute the reported novel-view synthesis quality.

Overall, FlexRM significantly outperforms baselines in both 1-view and 4-view settings. This improvement is particularly evident in the LPIPS score, a key metric reflecting perceptual quality, which demonstrates substantial gains. Beyond fixed input views, FlexRM is also capable of handling an arbitrary number of input views. We present results for 8-view and 16-view results, both exhibiting progressively stronger performance.
Qualitative results are shown in the Appendix D.

### 4.3 Ablation study and analysis

#### FlexRM in 3D Reconstruction.

We first ablate various design choices of FlexRM using 3D reconstruction metrics, including:
(1) not using the stronger camera conditioning,
(2) directly predicting positions ($\alpha=1$),
(3) not using positional offsets ($\alpha=0$), and
(4) not using two-stage training.
All experiments here are conducted on a weaker version of FlexRM, trained with 140,000 data points and for 20 epochs only in stage 2.
We use the same evaluation setting as in section 4.2.

Results are shown in table 3, where we report the averaged results across four different settings: 1, 4, 8, and 16 input views.
Overall, removing each component leads to a performance drop.
Notably, directly predicting positions and removing positional offsets result in significant performance decreases.
This highlights the importance of accurately modeling Gaussian positions for high-quality reconstruction.
Interestingly, removing stronger camera conditioning has a relatively smaller impact on performance.
This is because the advantages of stronger camera conditioning become more pronounced when a larger number of input views with varying camera poses are used.
To validate this, we also test a 32-view input experiment, where incorporating stronger camera conditioning improved PSNR by over 0.3 dB.

**Table 3: Ablation Study of FlexRM. We evaluate the impact of removing individual components of our proposed method.**
| Ablation | PSNR$\uparrow$ | SSIM$\uparrow$ | LPIPS$\downarrow$ | CLIP image sim$\uparrow$ |
| --- | --- | --- | --- | --- |
| No stronger camera cond | 24.31 | 0.871 | 0.092 | 0.865 |
| Directly predict positions | 23.41 | 0.840 | 0.096 | 0.831 |
| No positional offsets | 22.19 | 0.798 | 0.102 | 0.789 |
| No two-stage training | 23.38 | 0.838 | 0.098 | 0.827 |
| Full model | 24.35 | 0.873 | 0.090 | 0.868 |

#### Flex3D in 3D Generation.

Here we focus on the candidate view generation and selection pipeline, utilizing a fully trained FlexRM, fine-tuned with simulated imperfect data, as the reconstruction model.
The evaluation protocol follows that outlined in section 4.2.
We conduct ablation experiments by removing:
(1) multi-view generation at varying elevations,
(2) consistency verification (resulting in random view selection), and
(3) back view generation quality assessment.

Table 4 summarizes the results, demonstrating that the removal of any of these components leads to a decrease in both CLIP (Radford et al., ) and VideoCLIP (Wang et al., ) text similarity scores.
This shows the contribution of each component in achieving high-quality 3D generation.

**Table 4: Ablation study on Candidate View Generation and Selection. We show the results of ablating different components of our proposed candidate view generation and selection pipeline.**
| Ablation | CLIP text similarity$\uparrow$ | VideoCLIP text similarity$\uparrow$ |
| --- | --- | --- |
| No generation at varying elevations | 0.273 | 0.251 |
| No consistency verification | 0.269 | 0.248 |
| No back view quality assessment | 0.272 | 0.249 |
| Full model | 0.277 | 0.255 |

#### Imperfect Data Simulation.

We analyze our imperfect data simulation strategy using both reconstruction and generation metrics.
Evaluation settings mirror those used in the ablation study.
As shown in table 5, incorporating imperfect data simulation yields improvements across both generative and reconstruction tasks.
This suggests that our strategy effectively exposes the model to a wider range of data variations, enhancing its overall performance and robustness.

**Table 5: Ablation Study on Imperfect Data Simulation. Leveraging imperfect data simulation strategy leads to a reasonable performance improvement in generative tasks and a marginal improvement in reconstruction tasks.**
| Ablation | CLIP text sim$\uparrow$ | VideoCLIP text sim$\uparrow$ | PSNR$\uparrow$ | SSIM$\uparrow$ | LPIPS$\downarrow$ |
| --- | --- | --- | --- | --- | --- |
| No simulation | 0.271 | 0.250 | 24.87 | 0.888 | 0.086 |
| Full model | 0.277 | 0.255 | 24.90 | 0.889 | 0.084 |

## 5 Conclusion

This paper introduces Flex3D, a novel feed-forward 3D generation pipeline capable of creating high-quality 3D Gaussian representations from either text or a single image.
Its core component is FlexRM, a robust and flexible reconstruction model designed to handle an arbitrary number of input views.
Extensive evaluations on benchmark tasks demonstrate that Flex3D achieves state-of-the-art performance in both 3D reconstruction and generation tasks.
These results highlight the effectiveness of our proposed approach in addressing the challenges of feed-forward 3D generation, paving the way to more robust and versatile 3D content creation from diverse input sources.

## Ethics Statement

Our work explores generative AI with a focus on generating 3D Gaussian representations from pre-existing 2D content.
While we exclusively utilize ethically sourced and carefully curated training data, our model learns a generalized approach to 3D reconstruction.
This means that if presented with a problematic or misleading 2D image, our model could potentially generate a corresponding 3D object, though with some reduction in quality.
However, despite these inherent risks, we believe our work can empower artists and creative professionals by serving as a productivity-enhancing tool within their workflow.
Furthermore, this technology has the potential to boost 3D content creation by lowering barriers to entry and providing access to individuals who lack specialized expertise.

## Appendix A Implementation details

#### Training details.

Our FlexRM is trained in a two-stage manner.
In stage 1, we train it with 64 NVIDIA A100 (80GB) GPUs and use a total batch size of 512, where each batch consists of 4 multi-view images at a patch resolution of $128\times 128$ for supervision.
The input images have a resolution of 256 $\times$ 256, and the number of input images varies from 1 to 16.
The model is trained for 10 epochs with an initial learning rate of 2 $\times$ $10^{-4}$, following a cosine annealing schedule.
Training begins with a warm-up phase of 3000 iterations, and we use the AdamW optimizer (Loshchilov & Hutter, ).
We apply gradient clipping at 1.0 and a weight decay of 0.05, applied only to weights that are not biases or part of normalization layers.
Both training and inference are performed using Bfloat16 precision. The optimization target is a combination of three different losses: L2, LPIPS, and opacity, with corresponding coefficients of 1, 2, and 1, respectively.

Stage 2 utilizes 128 NVIDIA A100 (80GB) GPUs.
We increase the input image resolution to 512 $\times$ 512 and the maximum number of input images to 32.
We maintain a total batch size of 512, with each batch consisting of 4 multi-view images at a resolution of 512 $\times$ 512 for supervision.
The model is trained for 25 epochs.
All other training settings including total batch size are identical to Stage 1.

For further fine-tuning using simulated imperfect input views as input, we follow the setting in Stage 2 but only train it with 32 NVIDIA A100 (80GB) GPUs for 3 epochs.
We use a total batch size of 128 and an initial learning rate of 2 $\times$ $10^{-5}$.

Figure: Figure 5: View Selection Visualizations. We show some generated candidate views for each object. A green check mark indicates that our method selected the view, while a red cross indicates that the view was rejected. As the visualization demonstrates, our method can effectively filter out views that exhibit poor quality or inconsistent results, such as those with artifacts, truncations, or awkward perspectives. This allows us to focus on reconstruction from high-quality viewpoints, leading to improved overall results.
Refer to caption: x5.png

#### 3D Gaussian parameterization.

For predicted 3DGS parameters with 14 dimensions, we provide implementation details on converting them into position offset, color, opacity, scale, and rotation.
We follow the setting used in GS-LRM (Zhang et al., ) for opacity, scale, and rotation.

Position offset: We activate the predicted offset using a tanh function and apply a scaling factor of 0.25.
This scaled offset is then added to the initial positions to obtain the final 3DGS positions.

Color: We utilize the same activation function as in Neural Radiance Fields (NeRF).
The predicted color values are first passed through a sigmoid function, then multiplied by 1.002, and finally, 0.001 is subtracted.
These processed values serve as zero-order Spherical Harmonics coefficients for the 3DGS.

Opacity: We subtract 2.0 from the predicted opacity before applying a sigmoid function.
This approach ensures that the initial opacity values are around 0.1, which stabilizes the training process.

Scale: We subtract 2.3 from the predicted scale and then apply a sigmoid function.
Additionally, we clip the scale to a maximum value of 0.3 and a minimum value of 0.0001.
This design, similar to the opacity implementation, promotes stability during training.

Rotation: We predict unnormalized quaternions and apply L2-normalization as the activation function to obtain unit quaternions.

#### 3D Gaussian noise injection.

For all Gaussian parameters, we sample a small cube size within a range of 10 $\times$ 10 $\times$ 10 to 40 $\times$ 40 $\times$ 40, assuming a whole grid size of 100 $\times$ 100 $\times$ 100. Each time, the size is sampled individually for every parameter to achieve greater diversity. The noise levels for position, color, and opacity are set to 0.1, *i.e.*, a random noise between -0.1 and 0.1 is added. The noise level for scale is set to 0.02.

## Appendix B Limitations

While our method can generate high-quality 3D Gaussians, the inherent problems associated with 3DGS are also present.
For example, extracting clean meshes is not straightforward and usually requires multi-step post-processing. This issue can likely be mitigated in the near future given the fast development of Gaussians, either through new representations of Gaussians (Huang et al., ; Dai et al., ) or better ways to convert them to meshes (Wolf et al., ).
Though our paper focuses on 3D object generation, another potential limitation is that the tri-plane representation is usually limited by resolution size and cannot be easily used for large scene generation.

## Appendix C View selection visualizations

This section provides further visualizations to illustrate the effectiveness of our view curation pipeline.
Figure 5 showcases five randomly selected examples where our method successfully identifies and selects high-quality viewpoints while filtering out those with undesirable characteristics. Our method preserves high-quality views from multiple angles for objects, including front, side, and back views.

## Appendix D Qualitative Results on 3D Reconstruction

We show qualitative comparison results between FlexRM and reconstruction baselines in 1-view and 4-view settings (fig. 6 and fig. 7). FlexRM demonstrates a stronger ability to perform high-fidelity 3D reconstructions, particularly exceeding other baselines when observed from various elevation angles. This advantage is evident in both single-view and sparse-view scenarios. The results highlight FlexRM’s effectiveness in capturing fine details and overall object shape, leading to more accurate and visually appealing reconstructions.

Figure: Figure 6: Single-View Reconstruction Results, showcasing FlexRM’s ability to achieve reasonable reconstructions from only a single-view observation.
Refer to caption: x6.png

Figure: Figure 7: 4-view Reconstruction Results. FlexRM is able to perform high-fidelity sparse-view reconstructions that closely resemble the ground truth, particularly when viewed from different elevation angles, outperforming baseline reconstructors.
Refer to caption: x7.png

## Peer Reviews

confidence: 5
contribution: 2
initial_rating: 5
presentation: 4
questions: How many views are used for calculation metrics for Flex3d in Table 1? More than baseline methods? If so, is the comparison fair?
soundness: 3
strengths: - The writing is well-organized and easy to follow.
- This work proposed to select condition images from the generated multi-view images based on the quality, thereby improving the 3d reconstruction quality.
summary: This work focuses on feed-forward 3d generation. Following previous work, this paper adopts a synthesis-then-reconstruction method, where a multi-view diffusion generates multiple images at different camera views, and a regression model then reconstructs 3d representation based on multi-view images. The main contribution the author claimed is the view selection trick that curates generated multi-view images based on the back-view quality and consistency. Also, the proposed method uses 3DGS as a 3d representation for rendering efficiency.
weaknesses: - This work basically follows previous work like Instant3D and replaces the triplane NeRF representation with triplane Gaussian (as in [1]). The main contribution thus lies in the candidate view selection. It is evident that the reconstruction quality would improve with better generated multi-view images, but the key is how to define 'better' and automatically filter the better images. The proposed method adopts SVM trained with 2,000 manually labeled data to select back view, but the paper does not describe how to label the data and does not give the criterion. Also, 2,000 images are small and restricted by the bias of labelers. This would lead to very biased and uninterpretable labels for training a good classifier. How about the success rate of the selection model? How to determine whether it is a good classification? There is a lack of sufficient analysis and experiments that support the claim. There are similar concerns to the consistency selection model. Why do you choose manually crafted rules for selection, like using DINO, SVM, LOFTER? Are they the best choices? Any insights? 
- Based on the aforementioned comment, I would suggest the authors to compare with automatic selection with large multimodal model like GPT4V. It is straightforward to give the grid of images to the large model, and ask it to select images. Would it be better than the proposed method?
- There is a lack of comparison with diffusion-based baselines that predict 3d via 3d diffusion or 3d dit directly.
- The proposed method comprises two stages. Which stage does the improvement mainly come from? multi-view generation and selection, or flex reconstruction model? In Fig.4, and table 1, do the baselines use the same multi-view images as the proposed method? I would suggest evaluating two stages separately. Specifically, you may apply the view selection to baseline methods to check whether there are consistent improvements. Also, use the same selected multi-view images to evaluate different reconstruction model.
- For ablation results like table 3,4,5, do you use Blender rendered images or generated images as the multi-view condition? Could the data simulation address the domain gap of data? How about metrics in table 5 using GT multi-view images rather than generated multi-view images?


[1] Triplane Meets Gaussian Splatting: Fast and Generalizable Single-View 3D Reconstruction with Transformers

---

confidence: 5
contribution: 2
initial_rating: 6
presentation: 3
questions: See the weakness section.
soundness: 2
strengths: The paper is well-organized, with a clear delineation of the contributions and methodologies. The progression from problem identification to solution proposal is logical and easy to follow.

The key contributions of this paper are two-fold, which seem to be of effectiveness according to the experimental analysis:
1. candidate view generation and curation: Introduction of a multi-view generation strategy that produces a diverse set of candidate views from varying azimuth and elevation angles, followed by a selection process that filters views based on quality and consistency.
2. flexible reconstruction model (FlexRM): Development of a robust 3D reconstruction network capable of ingesting an arbitrary number of input views with varying viewpoints. FlexRM efficiently processes these views to output high-quality 3D Gaussian representations using a combination of tri-plane features and 3D Gaussian Splatting.

The authors conduct detailed ablation studies to validate the effectiveness of each component of their proposed framework.
summary: Flex3D is a novel two-stage framework for generating high-quality 3D content from text prompts, single images, or sparse-view images. In the first stage, it generates a diverse pool of candidate views using fine-tuned multi-view image diffusion models and video diffusion models. A view selection pipeline then filters these views based on quality and consistency. The second stage employs the FlexRM, a transformer-based architecture capable of processing an arbitrary number of input views with varying viewpoints. FlexRM combines tri-plane features with 3D Gaussian Splatting to produce detailed 3D Gaussian representations. Experimental results demonstrate that Flex3D outperforms state-of-the-art methods in both 3D reconstruction and generation tasks.
weaknesses: My major concerns lay in the following several aspects. If some of the may concerns can be solved during the discussion section, I would like to raise the final score.

1. The paper does not specify whether the proposed method has been tested across various datasets or object categories. Evaluating Flex3D on diverse and challenging datasets would demonstrate its generalizability and robustness to different types of input data.

2. The paper evaluates performance using 2D image-based metrics such as PSNR, SSIM, LPIPS, and CLIP image similarity. While these metrics are informative, they do not fully capture the geometric accuracy and consistency of the 3D reconstructions. Incorporating 3D-specific metrics, such as Chamfer Distance or Earth Mover's Distance, would provide a more comprehensive assessment of the reconstructed 3D models' quality.

3. The user study conducted to evaluate the overall quality of the generated content lacks detailed methodology. Information regarding participant demographics, selection criteria, and statistical significance testing is absent. Providing these details would enhance the credibility of the user study findings.

---

confidence: 4
contribution: 1
initial_rating: 5
presentation: 2
questions: I don’t really have technical questions, and it is rather unlikely that I will change my score (I hesitated between 5:weak reject and 3:reject). 
This is because, while the quality of writing is decent and results marginally improve on the state of the art, the paper reads more like a white-paper for re-engineering a large-scale system rather than answering any specific scientific question.

What are the **insights** that were not proposed before that could be adopted in follow-up research?
Or is this work just about combining previous techniques with the sole purpose of getting (very marginal) improvements to metrics?

And given the metrics improvements are so marginal (as revealed by the ablations), why does all of this complication really matter?
Perhaps the small improvement in metrics does not reflect a drastic improvement in qualitative performance… but I wasn’t able to see a drastic improvement in qualitative results on the supplementary website… so I am having a very hard time to consider all the proposed complications to be truly worth it.

For a system paper that needs 128 A100 to train, I would have expected a **much** larger improvement in performance to justify a white-paper as a technical conference paper. The story would be different if the pre-trained model and/or code+data was released, and the method tested on public benchmarks.
soundness: 3
strengths: - Visual quality: the results look good and similar/slightly better than previous works
- Back view quality assessment: using a multi-view video classifier to tackle typically lower back-facing views generation seems interesting, even though little information is provided.
summary: This paper proposes Flex3D, a method for feed-forward 3D generation. The method is split into two stages, i.e., multi-view generation and subsequent conversion of these generated multi-view images into 3D Gaussians for arbitrary view rendering. The first stage uses a multi-view image model and a image-to-video model to generate multiple viewpoints of a scene. The second stage uses a LRM-like pipeline to generate 3D Gaussians. The results show competitive quality compared to previous works.

UPDATE: given the additional experiments provided in the rebuttal that show how the proposed tweaks can improve other models, I go back from "reject" to my original rating of "marginally below". This partially resolves the closed-source issue (in response to [this](https://openreview.net/forum?id=2vaTZH31oR&noteId=nksfmi6e00). Nonetheless, the extent of contributions is still small, and this remains a borderline paper.
weaknesses: - There is a general lack of technical insights
- FlexRM stage already proposed (Stage 2): Previous works [1,2] in feed-forward 3D generation already proposed last year to decode triplane features into 3D Gaussian attributes.
- Multi-view image generation already proposed (Stage 1): MVDream [3] and follow-up works already turn pre-trained image generators into multi-view generators.
- Multi-view image generation with video model already proposed (Stage 1): Previous works [4,5] already proposed to use video generators for novel view synthesis given an image as an input.
- Conditioning with camera already proposed and marginal (Stage 2): previous works such as SV3D [5] already proposed to condition the generation with camera matrices. In this work it is used in the image encoder DINO. However, the ablation in Tab. 3 shows that the model with “No stronger camera cond” only shows very marginal improvement?
- Imperfect data simulation with marginal improvements (Stage 2): the data simulation part in the method section sounds rather complicated and unnecessary given its little impact in Tab. 5? Similar to the camera conditioning, the metrics only show very marginal improvement?
- No computational cost analysis: The method seems very complicated, it would be good to compare training and inference time against previous works.

References:
- [1] Zou et al., Triplane Meets Gaussian Splatting: Fast and Generalizable Single-View 3D Reconstruction with Transformers, arXiv 2023
- [2] Xu et al., AGG: Amortized Generative 3D Gaussians for Single Image to 3D, TMLR 2024
- [3] Shi et al., MVDream: Multi-view Diffusion for 3D Generation, ICLR 2024
- [4] Kwak et al., ViVid-1-to-3: Novel View Synthesis with Video Diffusion Models, CVPR 2024
- [5] Voleti et al., SV3D: Novel Multi-view Synthesis and 3D Generation from a Single Image using Latent Video Diffusion, ECCV 2024

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: 1. If the model is designed to be robust across various poses, view counts, and noise levels, could you provide visual results demonstrating this? For example, does the model perform well when given a side or back view as a single input? Additionally, how much inconsistency can be tolerated during the multi-view selection process?

2. Does the performance continue to improve as the number of views increases? How does the processing time scale with more views? If more views are beneficial, what strategies could be used to efficiently handle a greater number of input views?

3. It could be confusing if the notation for f in line 294 differs from f in line 288.

4. Where are the results for the 32-view test reported in line 489?

5. What would the outcome be if the selected views were used for a NeRF-based approach, similar to Instant3D? While GS may be preferred for faster training, NeRF could potentially yield better final performance.

6. Why are the two-stage training and imperfect input view simulation conducted as separate processes?
soundness: 3
strengths: 1. Logical Model Design and Well-organized Writing. Good logical model design and clarity of writing. It effectively identifies the limitations of existing models and systematically addresses them step by step, making the problem-solving process easy for readers to follow. This demonstrates a well-structured research design, facilitating readers’ comprehension of the methodology and approach.

2. Practicality. The techniques for multi-view generation, view selection, and robustness through data augmentation provide substantial applicability and reusability. The paper builds on an existing Instant3D architecture and employs a systemically optimized approach, suggesting high utility. It would be beneficial If authors release all the pre-trained models.
summary: The paper proposes a robust feedforward 3D generation pipeline to address inconsistent multiview inputs. Specifically, it fine-tunes multiview and video diffusion models to generate diverse viewing angles and incorporates a key view selection module using an existing feature-matching model. This approach ensures that high-quality and consistent views are chosen for 3D reconstruction.
weaknesses: 1. Incremental technical improvement. The suggested pipeline combines and optimizes existing techniques rather than introducing innovative algorithms. The approach appears to rely heavily on integrating and optimizing pre-existing technologies rather than presenting a novel concept or unique contribution. 

2. Complex Pipeline Requiring Extensive Fine-Tuning and Training. While the pipeline is logically structured, it is complex and demands extensive fine-tuning and training. Five rounds of fine-tuning are required. Initial multi-view generation involves data creation and two rounds of fine-tuning. The view selection step also utilizes existing models to build a new system module. Subsequently, the feed-forward model undergoes two additional rounds of fine-tuning, and the process includes one more phase of training with data augmentation. This level of complexity could hinder full implementation and reproducibility.

3. Performance Concerns Relative to Complexity. Given the overall complexity, the proposed model’s 3D generation performance shows rather minor improvements. For instance, as shown in Table 1, the performance metrics are slightly higher than those of other models.

---

confidence: 5
contribution: 3
initial_rating: 6
presentation: 3
questions: 1) Please show me some failure cases, especially for your view-selection method that failed.


2) Missing some Reference:

[1] Li W, Chen R, Chen X, et al. Sweetdreamer: Aligning geometric priors in 2d diffusion for consistent text-to-3d[J]. arXiv preprint arXiv:2310.02596, 2023.
[2] Qiu L, Chen G, Gu X, et al. Richdreamer: A generalizable normal-depth diffusion model for detail richness in text-to-3d[C]//Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition. 2024: 9914-9925.
[3] Chen R, Chen Y, Jiao N, et al. Fantasia3d: Disentangling geometry and appearance for high-quality text-to-3d content creation[C]//Proceedings of the IEEE/CVF international conference on computer vision. 2023: 22246-22256.
soundness: 3
strengths: 1) The paper is well-written and easy to follow. 

2) The results the author shows are compelling. 

3) The chosen multi-view strategy for improved quality is somewhat new.
summary: The author follow the classical two-stage 3D generation model: 1) Multi-view Generation; 2) A Large Gaussian reconstruction model conditioned on multi-view images from stage one to generate 3D Gaussian model. The author present a simple but effective sample strategy to choose some high-quality multi-view images among generated images as the inputs for the reconstruction stage.
weaknesses: The multi-view generation model is too heavy. It requires two multi-view generations to produce dense-view proposals. I believe this process is time-consuming and memory-intensive. What is the inference time required to produce the multi-view image proposals? Does it possible to apply video diffusion mode to generate  a trajectory where elevation varies according to the sine function, and azimuth is selected at equal intervals instead of two multi-view diffusion model?

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 2
questions: 1. Could the authors provide more insight into how the two multi-view generation models (focused on elevation and azimuth) avoid consistency issues, given the limited overlap between generated views?
2. How does FlexRM handle scenarios where significant view inconsistencies occur, especially as noisy input augmentation does not seem to address cross-view consistency?
3. Is there a visual or quantitative comparison available regarding FlexRM’s reconstruction flexibility when provided with a varying number of input views?
soundness: 2
strengths: 1. The two-stage process of generating and selecting views for flexible multi-view 3D generation is innovative and well-aligned with the goal of improving reconstruction quality.
2. The paper extensively validates each proposed module, demonstrating their significance through ablation studies and metrics across various tasks.
summary: The paper proposes Flex3D, a two-stage framework for generating high-quality 3D content using multi-view input views from a flexible reconstruction model. Initially, multiple candidate views are generated using separate multi-view diffusion models with distinct focus areas (elevation and azimuth), followed by a quality and consistency-based view selection. These selected views are then passed to a flexible reconstruction model (FlexRM), which leverages a tri-plane representation combined with 3D Gaussian Splatting (3DGS) for efficient 3D generation. Flex3D is shown to be effective in generating high-quality 3D representations and demonstrates state-of-the-art performance across several metrics in 3D generation and reconstruction tasks.
weaknesses: 1. **Lack of Cohesion in Core Contributions**: The proposed approach, although effective, seems overly complex and tricky, and doesn’t clearly reflect Flex3D's core innovation. For instance, using two different models to generate two groups of multi-view images, and adding noisy inputs during reconstruction make the approach appear fragmented and difficult to generalize.
2. **Inconsistency Concerns**: The method’s use of two different models for elevation and azimuth views results in overlapping views limited to one view (that is the view with elevation of 6), raising questions about cross-model consistency. This single overlap view may not fully capture the complete object appearance, potentially leading to inconsistencies between two view sets.
3. **Inadequate Simulation of Multi-View Inconsistencies**: The noisy input augmentation during FlexRM training accounts for view quality but does not adequately model cross-view inconsistencies, due to its operation on the 3DGS.
4. **Lack of Flexibility Analysis**: The paper lacks a visual ablation study on FlexRM’s performance with varying input views to illustrate the model's robustness to input flexibility.

Meta-review: In this paper, the authors have proposed Flex3D which is a feedforward method by first generating multi-view images and then reconstructing 3D contents. In the first stage, it selects views according to the quality and consistency. In the second stage, FlexRM is proposed to reconstruct 3D Gaussians. The paper obtains mixed scores of 5 and 6. From my point of view, the key limitation of this paper is the technical contributions are too engineering without providing more scientific insights, which is very important for a top conference paper. Also, the experimental improvements are not significant. Due to the reasons especially on the scientific novelty, I recommend a decision of rejection.

Decision: Reject