- Rating
- 2
- Confidence
- 4
- Informativeness
- 1
- Presentation
- 3
- Soundness
- 3
Read review
Paper summary
Feed-forward 3D reconstruction models are typically trained on image batches containing views of a single scene. Thus, providing images from multiple scenes at inference time can corrupt the predicted camera poses and 3D geometry. The state-of-the-art method Robust-VGGT addresses this issue without additional training, but requires two forward passes: one to partition the input images into distinct scenes (referred to as view graph initialization in this paper), and another to reconstruct them.
This paper proposes Graph3R, a method that performs both view graph initialization and 3D reconstruction in a single forward pass. To do so, a verification head is trained to predict pairwise co-visibility from the backbone features, producing a view graph that can be used to partition the input images into distinct scene groups. The verification head is trained jointly with LoRA adapters applied to the backbone, using 16 H200 GPUs.
One potential limitation of the approach is that all input images interact within the backbone before being partitioned into separate scenes, which could negatively affect reconstruction quality. However, the authors conduct a controlled experiment showing that reconstruction quality remains largely unaffected when processing images from up to three distinct scenes simultaneously.
The paper also presents several ablation studies investigating the training data mixture, the relative weighting of the training losses, and different backbone fine-tuning strategies.
The evaluation covers view graph initialization, depth consistency, camera pose estimation accuracy, and cross-session localization. Overall, Graph3R achieves competitive or superior performance compared to Robust-VGGT (or Robust-Pi3) and GLUEMAP across most benchmarks. In terms of computational efficiency, Graph3R is slightly faster than Robust-Pi3 and substantially faster than GLUEMAP, although it exhibits significantly higher peak memory.
Critical strengths
-
Simple approach -- The proposed method is simple approach able to combine view graph initialization and 3D reconstruction into a single forward pass. However, this comes at the cost of requiring additional training, unlike some competing approaches.
-
Extensive experimental evaluation -- The paper provides a comprehensive set of experiments covering view graph initialization, depth consistency, camera pose estimation accuracy, and cross-session localization, along with ablation studies examining several important design choices.
Critical weaknesses
-
Additional training requirements -- Unlike Robust-VGGT and GLUEMAP, which are training-free, Graph3R requires additional training of both the verification head and the backbone's LoRA adapters. This introduces additional computational costs and potentially limits the method's generalization to unseen domains. The paper does not sufficiently discuss this trade-off.
-
Difficulties in comparing with previous methods -- Although the paper presents extensive experimental results, the evaluation protocols appear to differ from those used in Robust-VGGT and GLUEMAP. This makes it difficult to directly compare the reported results and assess the extent of the improvements over existing approaches.
-
"Lightweight" verification head -- The authors describe the verification head as "lightweight". However, based on Table 3, it appears to contain approximately 69 million parameters. If this is actually the case, it does not seem particularly "light".
-
Limited evaluation of robustness to outliers -- If I am not mistaken, the paper only investigates the impact of processing images from up to 4 distinct scenes simultaneously. It remains unclear to me how the method behaves when the input consists of a single scene mixed with a large number of unrelated outlier images.
-
Lack of discussion of limitations -- The paper does not provide an explicit discussion of the limitations of the proposed approach.
Questions for authors
-
Training cost -- What is the total training time required for Graph3R? The paper mentions using 16 H200 GPUs, but I could not find the total training duration (although I may have overlooked this information in the appendix). Reporting the overall training cost would help clarify the computational trade-off between Graph3R and training-free alternatives.
-
Out-of-domain generalization -- Could the authors evaluate Graph3R against its competitors on a genuinely out-of-domain dataset? For instance, if indoor scenes are absent from the training mixture, evaluating on an indoor benchmark would provide useful insights into the generalization capabilities of the learned verification head and backbone adaptations. This is particularly relevant given that competing approaches do not require additional training.
-
Typo -- Line 205: "adopt".
-
Memory peak -- Why does Graph3R exhibit almost twice the peak memory consumption of its competitors? I could not find the explanation in the paper.
-
Robustness to outliers -- Could the authors investigate how reconstruction quality evolves when the input contains images from a single scene alongside an increasing number of unrelated outlier images. How robust is Graph3R in this setting, both in terms of view graph initialization and reconstruction accuracy?
-
Limitations -- Could the authors provide an explicit discussion of the limitations of Graph3R?
5 comments
(Continued from Part 1/4)
2. Evaluation protocols relative to RobustVGGT and GLUEMAP (W2)
“the evaluation protocols appear to differ from those used in Robust-VGGT and GLUEMAP.”
We agree and will clarify the exact scope of our comparisons. GLUEMAP is a complete global SfM pipeline that combines local multi-view reconstruction with global pose averaging and bundle adjustment (GLUEMAP pipeline). RobustVGGT evaluates a designated target scene mixed with distractors (30 clean views plus 10/30/50 distractors, or 14 clean views plus 5/14/30 distractors on ETH3D, averaged over 10 trials), and its repository currently provides demo inference while listing evaluation scripts as pending (RobustVGGT, Sec. 4.1; official repository).
In contrast, our task aims to recover all disjoint scene groups from mixed-scene collections without a designated target scene. Within each experiment, we compare all methods on identical inputs and ground-truth labels across two stages:
- View graph initialization: Evaluated via pairwise AP and MR following the conventions of Doppelgangers++ and GV-Bench, where GLUEMAP† denotes its SALAD retrieval and Doppelgangers++ verification modules.
- Reconstruction: The multi-view depth-consistency benchmark (Tables 4, 11, and 12) uses identical weights and shared geometry features across all scorers with connected components thresholded at , varying only the predicted grouping and retained view pairs. The pose benchmark (Tables 5 and 13) uses geometry for Graph3R, RobustPi3, and GLUEMAP, and VGGT geometry for the VGGT baselines, omitting GLUEMAP's global post-optimization for a direct feed-forward comparison.
Because these are controlled, component-level benchmarks, they should not be interpreted as reproducing the complete end-to-end evaluation pipelines of the original systems. In particular, group-wise decoding partitions existing predictions into separate scene groups without modifying individual poses or point maps; thus, higher consistency among retained pairs does not imply improved per-view geometry. We will make these distinctions explicit in the text and publicly release our fixed episodes, labels, and evaluation code.
3. “Lightweight” verification head (W3)
“it appears to contain approximately 69 million parameters.”
We agree with the reviewer and will remove the term “lightweight” throughout the paper. A detailed parameter audit shows 78.5M parameters for the verification head and 1.2M parameters for the LoRA adapters, totaling 79.7M (consistent with the rounded 80M reported for our final model in Table 3). The 69M figure reported for the frozen-backbone row omitted the 9.5M group self-attention layers, which we will correct. In terms of latency, the verification head itself requires 8 ms per nine-image batch. We will report both its exact parameter count and measured runtime directly.
4. Out-of-domain evaluation (Q2)
“Could the authors evaluate Graph3R against its competitors on a genuinely out-of-domain dataset?”
Because our 360Loc training split contains large indoor public spaces, we conducted an additional evaluation on ScanNet room-scale interiors, which are completely excluded from verification-head and LoRA training. Following our ETH3D protocol, we constructed 120 fixed episodes spanning 2, 3, or 4 validation rooms (4 views per room, Easy and Hard variants, with 20 episodes per setting). Ground-truth covisibility labels are derived from depth/pose reprojection with a minimum bidirectional overlap of 0.10, and all methods are evaluated on identical episodes and labels.
The comparison below uses the exact same paper checkpoint without adaptation (all values in %). ETH3D edge F1 is averaged across the six settings in Table 12, and all edge F1 metrics are computed at the fixed threshold :
| Method | ETH3D MR | ETH3D edge F1 at | ScanNet MR | ScanNet edge F1 at |
|---|---|---|---|---|
| GLUEMAP† | 93.17 | 64.33 | 82.33 | 46.06 |
| Graph3R | 91.41 | 96.35 | 93.58 | 94.10 |
| RobustPi3 | 65.38 | 86.89 | 84.20 | 93.37 |
| RobustVGGT | 49.97 | 58.78 | 41.40 | 60.85 |
(Continued in the next comment — Part 2/4)
(Continued from Part 2/4)
Although GLUEMAP† achieves a slightly higher MR on ETH3D, Graph3R attains the highest edge F1 among all methods on both benchmarks at the unchanged threshold . This demonstrates strong practical transfer of our decision rule without dataset-specific threshold retuning—an aspect not captured by threshold-free MR alone. Furthermore, Graph3R outperforms RobustPi3 and GLUEMAP† in ScanNet MR by 9.38 and 11.25 percentage points, respectively.
Note that while ScanNet is included in the underlying /VGGT reconstruction pretraining, it is unseen during our verifier and LoRA training; this experiment therefore specifically validates the out-of-domain transfer of the learned verifier.
5. Peak GPU memory consumption (Q4)
“Why does Graph3R exhibit almost twice the peak memory consumption of its competitors?”
We apologize for omitting this explanation in the paper. Memory profiling revealed an unused duplicate encoder and aggregator that was inadvertently loaded when initializing the geometry heads. Removing these redundant weights leaves all executed modules and model predictions completely unchanged. Re-measuring peak memory under Table 7's nine-image protocol on an A800 GPU yields:
| Configuration | Peak memory (GB) |
|---|---|
| Graph3R (original implementation) | 8.09 |
| Graph3R (unused duplicate weights removed) | 5.05 |
| RobustPi3 (re-measured) | 4.72 |
During inference, the visual encoder runs once, followed by two independent aggregation streams executed in a single batched call: LoRA-adapted features for verification and unadapted features for geometry. While both streams incur compute, the unadapted stream preserves the exact original predictions for the same joint input (note that group-wise decoding partitions these outputs without undoing cross-scene feature mixing).
Full-stage latency breakdown gives 16 ms (encoding) + 85 ms (aggregation) + 8 ms (verification) + 50 ms (geometry heads) = 159 ms, compared to 218 ms for RobustPi3. We will update Table 7 and Appendix A.8 with the corrected memory numbers and this clarified inference description.
6. Robustness to a single scene mixed with many outliers (W4, Q5)
“How robust is Graph3R in this setting, both in terms of view graph initialization and reconstruction accuracy?”
First, we clarify the outlier ratios already present in our main experiments. In ETH3D, each episode contains scenes with 4 views per scene (Appendices A.1 and A.3). Relative to any given target scene, there are cross-scene outlier views; thus, the setting already mixes 4 target views with 12 outlier views. Similarly, the OpenNavMap and 360Loc query evaluations process 1 query alongside 8 retrieved candidates, where candidate sets frequently contain more than 4 outliers—indeed, the 76.26% macro R@8 on OpenNavMap (Table 14) indicates that for over 23% of queries, all 8 retrieved candidates are outliers under the ground-truth criterion.
To directly isolate sensitivity to increasing outliers around a fixed main scene, we conducted an ETH3D stress test across 26 input families (two per scene). Each family consists of 8 connected main-scene views mixed with a nested set of outlier views drawn from other scenes (up to 32 total images), with identical inputs and covisibility labels shared across all methods.
View graph initialization. Evaluating MR at 100% precision across all main–main and main–outlier pairs gives:
| Method | ||||
|---|---|---|---|---|
| RobustVGGT | 64.35 | 47.13 | 32.06 | 26.08 |
| RobustPi3 | 69.38 | 54.07 | 54.07 | 15.55 |
| GLUEMAP† | 89.47 | 89.47 | 89.00 | 89.00 |
| Graph3R | 85.89 | 80.38 | 90.19 | 91.63 |
At , Graph3R reaches 99.55% AP / 91.63% MR. Using the unchanged threshold , Graph3R retains 97.1% of main-scene views, admits only 0.2% of outliers into the main group, and recovers the exact 8-view main group in 22/26 cases. By comparison, RobustPi3 and GLUEMAP† admit 69.9% and 97.6% of outliers into the main group, respectively, while RobustVGGT retains only 42.3% of main-scene views. Across all non-zero settings, Graph3R's outlier intrusion rate never exceeds 1.4%.
(Continued in the next comment — Part 3/4)
We thank Reviewer 6S0G for recognizing the simplicity of our approach and the breadth of our experimental evaluation. Before addressing each specific point, we would like to clarify the core research question motivating our work—“Can view graph initialization and feed-forward reconstruction be unified through one shared backbone pass?”—and highlight our contribution for the community:
We also agree that the additional training cost, evaluation protocol distinctions, and the effects of cross-scene feature mixing warrant clearer discussion, which we address in detail below.
1. Training cost and the trade-off with training-free methods (W1, Q1)
Training Graph3R takes approximately 10 hours on 16 NVIDIA H200 GPUs, corresponding to 160 GPU-hours in total. This is a one-time offline cost, and no scene-specific fine-tuning is required at inference time. We will report this total training cost in Section 4.
The table below combines our main paper results with an additional evaluation on ScanNet, using the exact same checkpoint without further training. Metrics are reported as AP / maximum recall at 100% precision (MR) (in %):
Graph3R achieves higher MR than both training-free baselines across all four datasets, including ETH3D and ScanNet, which are completely excluded from verification-head and LoRA training (we detail the ScanNet protocol in Section 4 below).
Note that GLUEMAP† relies on a pretrained learned verifier and therefore incurs no additional training in this comparison; thus, the table illustrates the overall performance–training-cost trade-off rather than isolating the effect of training alone. Within Graph3R, Table 3 provides a controlled ablation: adding LoRA to the trained-head, frozen-backbone variant increases mean MR from 57.07% to 73.06%. We will explicitly discuss both the training cost and the dependence on training data diversity in the revised manuscript.
(Continued in the next comment — Part 1/4)