acceptodds
Withdrawn from ICLR 2027

Graph3R: Unifying View Graph Initialization with Feed-Forward Reconstruction

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

Feed-forward reconstruction recovers camera poses and dense geometry from image sets whose views are assumed to come from a single scene. In practice, uncurated image collections often contain views from disjoint scenes, and reconstructing these views jointly can corrupt camera poses and geometry. Existing pipelines typically resolve view associations in separate stages before final reconstruction, leaving view graph initialization and reconstruction inference only loosely coupled. We introduce *Graph3R*, which ***unifies view graph initialization with feed-forward reconstruction through a shared geometric representation***. A lightweight verification head predicts pairwise covisibility from the multi-view features of to construct a view graph. This graph classifies the input views into scene groups. For each group, we mask the shared features before decoding camera poses and dense geometry. Reusing the multi-view features allows *Graph3R* to reconstruct disjoint scenes separately with a single backbone pass. Across three benchmarks, *Graph3R* improves average maximum recall at 100% precision by upto 8.99 percentage points over the baseline, while improving reconstruction quality on mixed-scene inputs. Regarding the multi-session mapping task, *Graph3R* improves cross-session localization and achieves competitive pose estimation accuracy, while delivering a runtime speedup of approximately over the baseline when reconstructing the query group. By integrating learned view association with geometric inference, our approach takes a step toward end-to-end reconstruction from uncurated image collections.

Primary area:
applications to robotics, autonomy, planning
Keywords:
Feed-forward Reconstruction, View Graph Initialization, Multi-session Mapping, Image Retrieval

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_6SoGOpenReview ↗
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
  1. 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.

  2. 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
  1. 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.

  2. 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.

  3. "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".

  4. 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.

  5. Lack of discussion of limitations -- The paper does not provide an explicit discussion of the limitations of the proposed approach.

Questions for authors
  1. 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.

  2. 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.

  3. Typo -- Line 205: "adopt".

  4. Memory peak -- Why does Graph3R exhibit almost twice the peak memory consumption of its competitors? I could not find the explanation in the paper.

  5. 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?

  6. Limitations -- Could the authors provide an explicit discussion of the limitations of Graph3R?

5 comments

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:

  • Unifying topology and geometry via shared representations: Prior pipelines treat view association and 3D reconstruction as loosely coupled stages—either relying on separate pairwise verifiers (e.g., GLUEMAP/Doppelgangers++) or requiring a second backbone pass after outlier rejection (e.g., RobustVGGT). Graph3R demonstrates that intermediate multi-view features from a feed-forward reconstruction backbone already encode sufficient geometric cues to predict global pairwise covisibility, eliminating redundant feature extraction.
  • Decomposing global failure into reliable local reconstructions: Feed-forward models typically force all input views into a single global coordinate frame, which severely corrupts poses and geometry when disjoint scenes are mixed (as illustrated in Fig. 1, left). By predicting a view graph from shared features and decoding each connected component independently, Graph3R decomposes an ill-posed global reconstruction problem into separate, well-posed local coordinate frames (Fig. 1, right), substantially improving reconstruction reliability and system-level accuracy on uncurated collections without rerunning the backbone. As discussed in the paper, addressing this problem is particularly valuable for spatial perception tasks such as multi-session mapping (e.g., OpenNavMap), where cross-session queries and retrieved candidates frequently mix views from disjoint locations.
  • Clear boundary and roadmap for future work: Through controlled experiments (Table 1) and our new outlier stress test (MM up to 24), we systematically quantify the exact cost of cross-scene feature mixing inside the shared aggregator. While this interference remains bounded enough to support reliable scene partitioning and local decoding today, eliminating cross-scene feature mixture within the aggregation layer represents a clear next step to further improve per-view geometric accuracy—a direction we explicitly highlight in our Limitations and Future Work.

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)

“What is the total training time required for Graph3R?”

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 %):

MethodGSV-Cities360LocETH3DScanNet
RobustVGGT (training-free)70.85 / 3.4691.89 / 15.3686.58 / 49.9790.24 / 41.40
RobustPi3 (training-free)74.89 / 0.2093.46 / 6.3197.76 / 65.3899.53 / 84.20
GLUEMAP†91.17 / 27.2996.13 / 74.7996.86 / 93.1793.56 / 82.33
Graph3R98.98 / 47.1799.65 / 83.6499.38 / 91.4199.37 / 93.58

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)

(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 π3\pi^3 weights and shared geometry features across all scorers with connected components thresholded at τ=0.5\tau = 0.5, varying only the predicted grouping and retained view pairs. The pose benchmark (Tables 5 and 13) uses π3\pi^3 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 τ=0.5\tau = 0.5:

MethodETH3D MR ↑\uparrowETH3D edge F1 at τ=0.5\tau = 0.5 ↑\uparrowScanNet MR ↑\uparrowScanNet edge F1 at τ=0.5\tau = 0.5 ↑\uparrow
GLUEMAP†93.1764.3382.3346.06
Graph3R91.4196.3593.5894.10
RobustPi365.3886.8984.2093.37
RobustVGGT49.9758.7841.4060.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 τ=0.5\tau = 0.5. 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 π3\pi^3/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 π3\pi^3 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:

ConfigurationPeak 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 π3\pi^3 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 K∈{2,3,4}K \in \{2, 3, 4\} scenes with 4 views per scene (Appendices A.1 and A.3). Relative to any given target scene, there are 4(K−1)∈{4,8,12}4(K - 1) \in \{4, 8, 12\} cross-scene outlier views; thus, the K=4K = 4 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 M∈{0,4,8,16,24}M \in \{0, 4, 8, 16, 24\} 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:

MethodM=4M = 4M=8M = 8M=16M = 16M=24M = 24
RobustVGGT64.3547.1332.0626.08
RobustPi369.3854.0754.0715.55
GLUEMAP†89.4789.4789.0089.00
Graph3R85.8980.3890.1991.63

At M=24M = 24, Graph3R reaches 99.55% AP / 91.63% MR. Using the unchanged threshold τ=0.5\tau = 0.5, 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 MM settings, Graph3R's outlier intrusion rate never exceeds 1.4%.


(Continued in the next comment — Part 3/4)

Reviewer_D61uOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper addresses feed-forward 3D reconstruction from unorganized image collections containing views from multiple disjoint scenes. The proposed method, Graph3R, attaches a lightweight verification head to the π3\pi^3 backbone to predict pairwise covisibility directly from shared backbone features. Connected components of the resulting view graph are then used to partition the images into scene groups, which are decoded separately from the same cached features to avoid a second backbone pass. The authors evaluate Graph3R on pairwise verification, depth consistency, pose accuracy, and cross-session localization in a multi-session mapping setup, reporting stronger verification metrics and substantial speedups over GLUEMAP.

Critical strengths

S1. Within its training domains, the learned verification head clearly outperforms the baselines in Table 2 while adding minimal latency. It also achieves the best cross-session reranking results on the unseen OpenNavMap benchmark, albeit by small margins. This provides solid evidence that π3\pi^3's backbone features are informative enough to support covisibility classification.

Critical weaknesses

W1. I may be misunderstanding how grouping works, and I will lean toward rejection unless the authors can clarify this. Section 3.3 says that grouping restricts cross-view attention during decoding. However, in π3\pi^3, cross-view attention happens only in the aggregation backbone, not in the decoders. Graph3R describes gathering aggregated features ZZ, but doesn't mention any changes to the decoders. With fixed features and unchanged decoders, Dω(Z[Vk])=Dω(Z)[Vk]D_\omega(Z[V_k]) = D_\omega(Z)[V_k]. As far as I can tell, this operation just partitions the outputs without changing any view's predicted pose or pointmap (unless DωD_\omega includes cross-view layers from the backbone, which isn't described). Furthermore, since Appendix A.5 keeps the reconstruction weights and features fixed, don't the differences in Tables 4 and 11 come purely from which view pairs and episodes are kept, rather than better underlying geometry?

W2. I am also not convinced that the model runs in a single backbone pass. Verification uses LoRA-adapted features, while the reconstruction evaluations use base π3\pi^3 features and weights. Appendix A.8 mentions "dual-stream runs and cached base geometry features," but doesn't explain how both streams are generated or whether the timing numbers include computing all required features. Since "reconstruction with a single backbone inference" is a main claim of the paper, please clarify how this works in practice.

Questions for authors

Q1. Why is RobustVGGT left out of Table 4, especially since it matches or beats Graph3R on average MVS/δ1\delta_1 in Table 11?

Q2. Per Appendix A.1, two of the three benchmarks behind Table 2's headline average (GSV-Cities and 360Loc) are in-distribution validation splits for Graph3R, whereas GLUEMAP† is trained on external data. On the sole held-out set in Table 2 (ETH3D), Graph3R trails GLUEMAP† in MR (91.41 vs. 93.17), and the pairwise LoRA variant in Appendix A.9 trails Doppelgangers++ and MegaLoc on zero-shot GV-Bench MR (15.79 vs. 25.75 and 32.38). How do these held-out results support Sec. 4.2's claim that the training mix "improves generalization"?

3 comments

We thank Reviewer D61u for the careful reading and constructive feedback. Below, we clarify our decoder formulation and inference mechanism and provide the requested empirical analyses.

Before addressing each point in detail, we want to explain the key design principle of Graph3R clearly: rather than relying on separate pairwise verifiers or running a second backbone pass, Graph3R demonstrates that view graph initialization and feed-forward reconstruction can be unified through a single shared geometric representation. When uncurated collections contain disjoint scenes, forcing all views into a single global coordinate frame severely corrupts poses and geometry (Fig. 1, left). By inferring a view graph from shared backbone features and decoding each connected component independently, Graph3R decomposes an ill-posed global reconstruction problem into independent, well-posed local coordinate frames (Fig. 1, right). This design substantially improves reconstruction reliability without rerunning the backbone, while isolating cross-scene feature mixture in the aggregator as a clear, well-bounded target for future refinement.

W1. Grouping and reconstruction quality

“this operation just partitions the outputs”

We thank the reviewer for pointing out the ambiguity in our wording. Because π3\pi^3's decoders operate independently on each view, Dω(Z[Vk])=Dω(Z)[Vk]D_\omega(Z[\mathcal{V}_k]) = D_\omega(Z)[\mathcal{V}_k] indeed holds for fixed features. By design, group-wise decoding partitions the predicted outputs into separate scene reconstructions and restricts downstream pair and group evaluation to within-group views, without altering individual per-view poses or point maps. We will revise Section 3.3, Contribution (b), and the captions of Tables 4 and 11 to state this mechanism with complete precision.

Rationale and sufficiency of post-aggregation grouping: Consistent with our objective of reusing a single shared representation across both tasks, Graph3R computes the aggregated features ZZ once and avoids a second backbone pass. While post-aggregation grouping does not alter cross-view attention within the aggregator, our empirical results demonstrate that reusing the shared representation is sufficient to preserve reconstruction fidelity while providing essential scene-level isolation:

  1. Minimal cross-scene interference in shared features: Table 1 directly compares joint aggregation against independent per-scene backbone inference on ETH3D. Even when mixing up to K=4K=4 disjoint scenes in a single aggregation pass, ground-truth depth accuracy exhibits minimal degradation (at most a 1.93% relative decrease in δ1\delta_1 and a 4.08% relative increase in AbsRel). This confirms that π3\pi^3's shared geometric features retain high geometric fidelity for separate scene recovery without rerunning the backbone.
  2. Effective scene isolation for downstream tasks: Without view-graph partitioning, raw feed-forward models collapse disjoint scenes into a single corrupted coordinate frame and retain false cross-scene pairs (as seen in the π3\pi^3 and VGGT baselines in Table 5). Partitioning the decoded outputs via the predicted view graph cleanly separates disjoint scenes into coherent local frames and filters out cross-scene outliers, yielding substantial gains in system-level pose accuracy (Table 5) and cross-view consistency among retained pairs (Tables 4 and 11) at a fraction of the latency (Table 7).

We will clarify both the exact mathematical behavior of DωD_\omega and this core design rationale in the revised manuscript. We hope such clarification can avoid your confusion.

W2. Inference mechanism and efficiency

“whether the timing numbers include computing all required features”

In our pipeline, the visual encoder runs only once, and its output tokens feed two independent streams within a single batched aggregator call: LoRA-adapted features for verification and unadapted base features for geometry. Thus, the cached geometry features are generated directly during this forward pass, and our timing measurements account for computing all required features. We will replace the phrasing “single backbone pass” with one encoder pass followed by batched dual-stream aggregation to make both streams explicit.

Under the nine-image, all-groups evaluation protocol in Table 7, full-stage runtime profiling yields 16 ms (encoding) + 85 ms (aggregation) + 8 ms (verification) + 50 ms (geometry heads) = 159 ms, compared to 218 ms for RobustPi3 and 4,663 ms for the evaluated GLUEMAP baseline—representing a 29.3$\times$ speedup over GLUEMAP. Furthermore, removing an unused duplicate π3\pi^3 encoder and aggregator from the implementation reduces peak GPU memory from 8.09 GB to 5.05 GB (compared to 4.72 GB for RobustPi3). We will update Table 7 and Appendix A.8 accordingly.


Unfinished. Please keep reading the comments.

Q1. RobustVGGT and coverage

“Why is RobustVGGT left out of Table 4”

We apologize for this oversight. RobustVGGT was included in Appendix Table 11, where it achieves stronger Easy consistency and slightly better average MVS and δ1\delta_1. We will incorporate RobustVGGT into main Table 4 and qualify our discussion in Section 4.3 accordingly.

To provide a fuller picture alongside consistency, our additional analysis across 120 ETH3D episodes at τ=0.5\tau = 0.5 shows:

MethodImages in non-singleton groupsExact scene partitionsEpisodes with cross-scene merges
Graph3R98.4%90/12010/120
RobustVGGT52.6%0/12033/120

Graph3R retains substantially more views and recovers far more exact scene partitions, while neither method produces an episode with zero retained pairs. We will report these coverage statistics alongside consistency in the revision.

Q2. Generalization and a consistent decision threshold

“How do these held-out results support … ‘improves generalization’?”

We will narrow our claim regarding Table 3 to reflect improved validation performance within the training domains. A distinct practical advantage of Graph3R, however, is that it operates with a fixed decision threshold (τ=0.5\tau = 0.5) across datasets without dataset-specific retuning. While maximum recall at 100% precision (MR) summarizes performance under an oracle threshold, a higher MR does not necessarily translate to better view graphs at a deployed operating threshold.

In the table below, ETH3D edge F1 is averaged across the six settings in Table 12 using τ=0.5\tau = 0.5 for all methods. We also evaluate the exact same checkpoint from the paper without further training on 120 mixed-scene ScanNet episodes constructed following the ETH3D protocol, with identical episodes and ground-truth labels shared across all methods (values in %):

MethodETH3D MR ↑\uparrowETH3D edge F1 at τ=0.5\tau = 0.5 ↑\uparrowScanNet MR ↑\uparrowScanNet edge F1 at τ=0.5\tau = 0.5 ↑\uparrow
GLUEMAP†93.1764.3382.3346.06
Graph3R91.4196.3593.5894.10
RobustPi365.3886.8984.2093.37
RobustVGGT49.9758.7841.4060.85

Although GLUEMAP† attains a higher MR on ETH3D, Graph3R achieves a substantially higher edge F1 and 90/120 exact scene partitions (versus 18/120 for GLUEMAP†) at the unchanged threshold τ=0.5\tau = 0.5. Similarly, on ScanNet—which is completely excluded from our verifier and LoRA training (though included in the underlying π3\pi^3/VGGT reconstruction pretraining)—Graph3R achieves both the highest MR (93.58%) and the highest edge F1 (94.10%) at τ=0.5\tau = 0.5. Together, these results demonstrate strong practical transfer of our learned verifier and fixed decision rule to unseen benchmarks without threshold retuning.

Additionally, Graph3R performs verification jointly across multiple views, whereas GLUEMAP† relies on a separate pairwise Doppelgangers++ verifier prior to multi-view reconstruction—contributing to the runtime advantage reported above.

Finally, the GV-Bench results evaluate a separate pairwise variant trained solely on VisymScenes and Doppelgangers, whose weaker transfer likely stems from limited training diversity. We will explicitly acknowledge this limitation and highlight broader training coverage as a direction for future work.

Dear Reviewer D61u,

Thank you again for your time and constructive feedback! We have uploaded the revised PDF (with the main updates highlighted in blue) incorporating your suggestions:

  • Grouping (W1): your reading is correct. The decoders act on each view independently, so grouping partitions the outputs into separate scene-level reconstructions without changing any view's prediction; the statement about cross-view attention during decoding is removed (Sec. 3.3)
  • Depth consistency (W1): all scorers share the same π³ weights and geometry features, so the differences in Tables 4 and 11 come from the grouping and the retained pairs, not from better underlying geometry (Sec. 4.3, Appendix A.5)
  • Inference (W2): the "single backbone pass" claim is replaced by an exact description, one encoder pass followed by batched dual-stream aggregation, with a per-stage latency breakdown that covers all stages (Sec. 3.3, Appendix A.8)
  • RobustVGGT (Q1) is added to Table 4, together with coverage and grouping-failure statistics for all methods (Sec. 4.3, Appendix A.14, Table 24)
  • Generalization (Q2): the claim is narrowed to the training domains, the ETH3D MR gap to GLUEMAP† is stated explicitly, and fixed-threshold results on ETH3D and the unseen ScanNet are added (Sec. 4.2, Appendix A.15, Table 25)

We would greatly appreciate it if you could review our responses and let us know if they address your concerns. Your two main points directly reshaped the method description: the paper no longer claims that grouping alters decoding or that inference uses a single backbone pass, and the depth-consistency results are now presented as a comparison of groupings over shared geometry. If you have any further questions or comments, we would be delighted to engage in discussion. Thank you once again for your time and consideration!

Reviewer_R11aOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary
  1. Method. The paper proposes Graph3R, a system for reconstructing uncurated image collections that may contain views from multiple disconnected scenes. It builds on π3 and reuses its multi-view backbone features for both view association and reconstruction.

  2. Pipeline. A transformer-based verification head pools the shared features into per-view descriptors and predicts pairwise covisibility. Scores above 0.5 form an undirected view graph, whose connected components define scene groups. Graph3R then gathers the already-computed features belonging to each non-singleton component and separately decodes its camera poses, dense point maps, and confidence maps, avoiding another backbone pass.

  3. Training and validation. The verifier is trained with pairwise overlap classification and scene-identity supervised contrastive losses; the selected configuration also applies full-layer LoRA to the π3 backbone. Experiments evaluate oracle-group feature reuse, view-graph prediction, mixed-scene geometry and pose estimation, OpenNavMap retrieval reranking, and runtime. Graph3R reports strong association results and competitive reconstruction and localization accuracy.

Critical strengths
  1. A simple and useful integration of view grouping and reconstruction. Graph3R uses the same geometric representation for verification and group-wise decoding, avoiding repeated backbone feature extraction. Table 1 suggests that, with oracle groups, cross-scene feature mixing causes only modest degradation for up to four ETH3D scenes.

  2. Strong reported results over several aspects of the pipeline. Graph3R achieves high in-domain view-graph precision and recall, improves many pose and depth-consistency results, and provides favorable latency under the tested nine-image setting. The paper also evaluates association, geometry, pose, retrieval reranking, runtime, and memory rather than reporting only pair-classification accuracy.

Critical weaknesses
  1. The evaluation lacks the decisive frozen retrieval-plus-reconstruction baseline. A direct alternative is to compute image similarity with a standard pretrained retrieval model such as NetVLAD or Patch-NetVLAD, form groups using the same thresholding or clustering rule, and reconstruct each group with frozen VGGT or π3, without any fine-tuning. CosPlace, AnyLoc, or MegaLoc would also be informative modern choices. Although retrieval similarity is not identical to geometric covisibility, this baseline would test whether Graph3R's learned covisibility head and adapted shared features provide value beyond a simple retrieval-based grouping pipeline. It is particularly important because Graph3R receives task-specific training and LoRA adaptation while RobustPi3 and RobustVGGT do not. In the separate pairwise training setting of Appendix A.9, zero-shot GV-Bench results also favor MegaLoc (91.74 AP and 32.38 MR) over Graph3R-LoRA (85.17 AP and 15.79 MR), suggesting that generalization deserves closer study; these numbers should not, however, be interpreted as evaluation of the main multi-view checkpoint.

  2. The experiments do not disentangle supervised adaptation from the proposed unification. The frozen-backbone-versus-LoRA ablation changes Graph3R itself but does not provide matched-capacity or matched-supervision baselines. A retrieval model trained on the same GSV-Cities/360Loc data, or a Graph3R verifier trained on frozen π3 features compared with frozen retrieval descriptors under identical grouping and π3/VGGT decoding, is missing. Table 1 uses oracle groups and identical π3 weights for both conditions, but the paper does not clearly state whether these are the final LoRA-adapted weights; in either case, this controlled experiment does not evaluate the final predicted-group pipeline. Thus, the strong selection results do not by themselves demonstrate that shared geometric features are the source of the gains.

  3. The reconstruction presentation and evaluation protocol need stronger controls. Relative to the methods displayed in main Table 4, Graph3R is best across all reported metrics. However, Appendix Table 11 adds RobustVGGT, which is better on all three Easy metrics and slightly better in average MVS and δ1\delta_1. The broad wording in Section 4.3 should therefore be qualified, and the omission of this result from the main table makes the headline comparison incomplete. More fundamentally, the methods reconstruct different retained pair sets, isolated views are excluded, and no coverage or failure rate is reported. Ground-truth depth accuracy on a fixed set of images/pairs, including episodes with no retained pair, would be more conclusive.

  4. Generalization, scaling, and reproducibility evidence is limited. GSV-Cities and 360Loc are both training sources and headline evaluation datasets, while location-level train/evaluation separation is not fully documented. ETH3D uses only 20 fixed episodes per setting without uncertainty across seeds. The connected-component grouping can merge two scenes after a single false-positive edge, yet robustness is not studied as the collection size or number of scenes grows. The headline runtime experiment uses only nine images, although pair scoring is quadratic and decoding cost depends on the number of predicted components. Finally, Table 10 compares checkpoints trained for substantially different numbers of steps, weakening the adaptation and loss ablations.

Questions for authors
  1. How does Graph3R compare with NetVLAD or Patch-NetVLAD similarity followed by the same thresholding/connected-component grouping and frozen VGGT or π3 reconstruction? Please also consider strong pretrained descriptors such as CosPlace, AnyLoc, or MegaLoc, with no task-specific fine-tuning.

  2. Can the authors provide training-matched comparisons in which Graph3R and retrieval baselines use the same GSV-Cities/360Loc supervision and optimization budget, as well as fully frozen comparisons? How much of the gain comes from the verification head, contrastive supervision, and LoRA adaptation separately?

  3. Does the geometry decoder consume the LoRA-adapted backbone features, and does adapting those features affect π3's pose and point-map quality? How do final-model shared decoding, rerunning frozen π3 per predicted group, and oracle grouping compare? What exactly are the “dual-stream runs and cached base geometry features” in Appendix A.8?

  4. Can the authors report ground-truth reconstruction accuracy, retained-image/pair coverage, singleton and empty-group rates, and failure rates on a common evaluation set? Please clarify why RobustVGGT is omitted from main Table 4 despite outperforming Graph3R on several metrics in Appendix Table 11.

  5. How is symmetry of the pair score enforced, and how robust is connected-component grouping to one false-positive edge as the number of input images grows? Please provide results for larger collections together with the missing verifier, LoRA, label-construction, training, and split details.

6 comments

We thank Reviewer R11a for recognizing the value of integrating view grouping with reconstruction and the breadth of our evaluation. Our core research question is whether view graph initialization and feed-forward reconstruction can be unified by reusing geometric representations. For uncurated collections containing disjoint scenes, Graph3R predicts scene associations from reconstruction features and reuses the jointly computed geometry across the resulting scene groups, avoiding per-group backbone reruns.

We agree that substantiating this contribution requires rigorous evidence regarding both association quality and the trade-off between accuracy and efficiency of feature reuse. Following your suggestions, we have added frozen retrieval baselines, training-data controls, ground-truth (GT) depth evaluations on a common set of images, coverage statistics, and an outlier stress test. All evaluations of the main Graph3R model use the exact same checkpoint from the paper without additional training; Section 2 separately details the training-control configurations. Together, these experiments clarify the benefits and limitations of our learned verifier and cross-scene geometry reuse.

1. Frozen retrieval pipelines and fixed-threshold deployment (W1, Q1)

“How does Graph3R compare with NetVLAD or Patch-NetVLAD similarity followed by the same thresholding/connected-component grouping and frozen VGGT or π3\pi^3 reconstruction?”

We thank the reviewer for suggesting this direct comparison. We evaluate frozen NetVLAD, Patch-NetVLAD, CosPlace, and MegaLoc descriptors, alongside a retrained SALAD control. Retrieval ranking and covisibility verification address related but distinct objectives: a top-ranked image is not necessarily geometrically covisible, whereas view-graph construction requires deciding which specific pairs to connect.

To evaluate retrieval models for view-graph initialization, we use descriptor similarity as the edge score and compute metrics on the exact same image pairs and GT covisibility labels as Graph3R at an input resolution of 224×224224 \times 224. Average precision (AP) summarizes the precision–recall curve, while MR denotes the maximum recall achievable at 100% precision. Graph3R’s verification head outputs learned scores in [0,1][0, 1], and we apply the same decision threshold τ=0.5\tau = 0.5 across all evaluated benchmarks without dataset-specific retuning. The table below reports AP / MR (%):

MethodGSV-Cities360LocETH3DAverage
NetVLAD (frozen)89.26 / 1.4987.07 / 54.2198.10 / 86.0291.48 / 47.24
Patch-NetVLAD (global, frozen)90.86 / 5.3586.45 / 46.8694.34 / 61.1790.55 / 37.79
CosPlace (frozen)95.54 / 18.2687.84 / 58.0591.56 / 55.8091.65 / 44.04
MegaLoc (frozen)99.25 / 37.8991.68 / 63.26100.00 / 99.4596.97 / 66.87
SALAD (GSV-Cities retrained)99.41 / 53.4491.09 / 60.7799.39 / 87.4096.63 / 67.20
Graph3R98.98 / 47.1799.65 / 83.6499.38 / 91.4199.34 / 74.07

Graph3R achieves the highest average AP and MR, while MegaLoc leads on ETH3D and retrained SALAD leads on GSV-Cities. We will include these competitive baselines in the revision, noting that MegaLoc's pretraining includes our GSV-Cities evaluation city, whereas our retrained SALAD control excludes it.


(Continued in the next comment — Part 1/5)

(Continued from Part 1/5)

We argue that in practice, an uncurated collection provides no GT covisibility labels to tune a collection-specific threshold. We therefore evaluate graph construction at the prescribed threshold τ=0.5\tau = 0.5 without test-set retuning. The table below reports edge F1 and ETH3D cross-view consistency averaged across all six settings, with all three predicted-group pipelines using this fixed threshold.

Unlike the shared-geometry scorer comparison in Tables 4, 11, and 12, the retrieval pipelines in this experiment rerun frozen π3\pi^3 separately for each predicted group. Graph3R reuses jointly computed geometry, and the GT-group reference applies per-group π3\pi^3 reconstruction.

Pipelineτ\tauEdge F1 (%) ↑\uparrowMVS ↑\uparrowAbsRel ↓\downarrowδ1\delta_1 (%) ↑\uparrow
NetVLAD + per-group π3\pi^30.50041.740.0740.61158.5
Patch-NetVLAD + per-group π3\pi^30.50041.690.0740.61158.5
Graph3R (shared geometry)0.50096.350.2230.29274.2
GT groups + per-group π3\pi^3——0.2270.27974.9

At the fixed threshold τ=0.5\tau = 0.5, Graph3R achieves 96.35% edge F1—compared with 41.74% for NetVLAD and 41.69% for Patch-NetVLAD—while approaching the cross-view consistency of the GT-group reference. This demonstrates the practical value of Graph3R’s fixed decision rule on mixed-scene collections. Because raw descriptor similarities and learned verification probabilities follow different distributions, these results specifically reflect performance under a fixed deployment threshold, whereas the AP/MR comparison above captures threshold-independent ranking quality.

2. Training controls and the contribution of feature reuse (W2, Q2)

“The experiments do not disentangle supervised adaptation from the proposed unification.”

We agree that verification learning should be decoupled from the trade-off between accuracy and efficiency of feature reuse. To control for training data, we retrained SALAD and compared it against Graph3R variants on the exact same GSV-Cities split (holding out WashingtonDC, with λ=0\lambda = 0 for Graph3R). Results are reported as AP / MR (%):

ConfigurationGSV-Cities360Loc
SALAD (frozen backbone; trained aggregator)98.97 / 18.4789.25 / 62.58
Graph3R (frozen backbone; trained head)98.59 / 19.5888.51 / 28.46
SALAD (last four backbone blocks trained)99.41 / 53.4491.09 / 60.77
Graph3R (LoRA)99.14 / 54.0195.94 / 32.15

With matched training data, the adapted models perform comparably on GSV-Cities. On the unseen 360Loc dataset, Graph3R achieves higher AP, whereas SALAD achieves higher MR. While this experiment aligns the GSV-Cities training split, model capacities and optimization budgets still differ, and it does not replicate our final model’s mixed-dataset training.

Table 3 further compares Graph3R variants under the 4:1 training mixture. The head-only, head + contrastive loss, head + LoRA, and full combined configurations achieve mean MR values of 57.46%, 57.07%, 57.25%, and 73.06%, respectively (weighting the GSV-Cities split mean and 360Loc equally). As documented in Table 10, these checkpoints were trained for different numbers of steps. While the combined configuration performs best, these ablations do not strictly isolate each component under an identical optimization budget. We will state this limitation explicitly in the revision.

To isolate feature reuse itself, Section 3 holds both the predicted groups and original π3\pi^3 weights fixed, directly comparing shared geometry against per-group backbone reruns. This evaluates the trade-off between accuracy and efficiency of feature reuse independently of association differences.


(Continued in the next comment — Part 2/5)

(Continued from Part 2/5)

3. Geometry features, shared decoding, and efficiency (Q3)

“Does the geometry decoder consume the LoRA-adapted backbone features [...]? How do final-model shared decoding, rerunning frozen π3\pi^3 per predicted group, and GT grouping compare?”

The geometry decoders consume only the original π3\pi^3 features; LoRA adapts only the verification stream. During inference, the visual encoder runs once, followed by two independent aggregation streams executed in a single batched call. The unadapted stream produces the cached geometry features within the same pass, and all reported runtimes include this full computation. In the revision, we will replace “single backbone pass” with one encoder pass followed by batched dual-stream aggregation.

Because the decoders of π3\pi^3 operate independently per view, Dω(Z[Vk])=Dω(Z)[Vk]D_\omega(Z[\mathcal{V}_k]) = D_\omega(Z)[\mathcal{V}_k] holds for fixed features ZZ. Grouping partitions the predictions without altering per-view poses or point maps, nor does it undo cross-view interference from the aggregator. Instead, the crucial difference lies in replacing a single, globally aligned reconstruction across all views with separate scene-level reconstructions for each predicted group, avoiding invalid alignment across disconnected scenes.

Table 1 uses original π3\pi^3 weights and GT groups, showing that mixing up to four scenes incurs at most a 1.93% relative drop in δ1\delta_1 and a 4.08% relative increase in AbsRel compared with independent per-scene inference. To evaluate the final predicted-group pipeline, we additionally measure GT depth across all input images using common masks and per-scene median-scale alignment. ETH3D Easy results are reported as AbsRel / δ1\delta_1 (%):

Geometry computationK=2K = 2K=3K = 3K=4K = 4
Shared features (Graph3R predicted groups)0.098 / 91.90.097 / 92.10.102 / 91.4
Frozen π3\pi^3 rerun per predicted group0.099 / 92.80.097 / 92.80.097 / 93.1
Frozen π3\pi^3 rerun per GT group0.098 / 92.90.097 / 93.40.098 / 93.2

With shared features, GT grouping and no grouping yield identical per-view GT depth. Rerunning the backbone per predicted group improves δ1\delta_1 on Easy, but increases geometry-stage latency from 0.226 to 0.328 s at K=4K = 4. On Hard, however, per-group reruns reduce δ1\delta_1 by ~1.5 percentage points at K=3,4K = 3, 4, indicating that reruns are not uniformly beneficial. Comparing shared geometry against per-group reruns on the exact same predicted groups directly quantifies the trade-off between accuracy and efficiency of feature reuse.

Under the nine-image, all-groups protocol in Table 7, end-to-end latency is 16 ms (encoding) + 85 ms (aggregation) + 8 ms (verification) + 50 ms (geometry heads) = 159 ms, compared with 91 ms for standalone π3\pi^3, 218 ms for RobustPi3, and 4,663 ms for the GLUEMAP baseline. Removing redundant duplicate backbone weights reduces peak memory from 8.09 to 5.05 GB without altering predictions (versus 4.72 GB for RobustPi3). We will update the inference description and memory numbers accordingly.

4. Reconstruction coverage and RobustVGGT (W3, Q4)

“Please clarify why RobustVGGT is omitted from main Table 4 despite outperforming Graph3R on several metrics in Appendix Table 11.”

We apologize for this omission. RobustVGGT achieves stronger consistency on Easy and slightly better average MVS and δ1\delta_1; we will include it in Table 4 and qualify our claims in Section 4.3. We also agree that consistency among retained pairs must be interpreted alongside view coverage, grouping failures, and GT accuracy. In Tables 4, 11, and 12, all scorers share identical π3\pi^3 weights and geometry features, differing only in their predicted groupings and retained pairs. Higher consistency on a subset of retained pairs therefore does not imply better underlying per-view geometry. Across the 120 ETH3D episodes at τ=0.5\tau = 0.5, we observe:

MethodImages in non-singleton groupsSingleton imagesEpisodes with cross-scene mergesExact scene partitions
Graph3R98.4%1.6%10/12090/120
GLUEMAP†100.0%0.0%102/12018/120
RobustPi399.4%0.6%62/12051/120
RobustVGGT52.6%47.4%33/1200/120

(Continued in the next comment — Part 3/5)

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Discussion (0)

Sign in to comment.