- Rating
- 2
- Confidence
- 4
- Informativeness
- 2
- Presentation
- 3
- Soundness
- 2
Read review
Paper summary
This paper proposes a graph construction method called “Edge Soup,” which represents scale as an additional node coordinate and uses kNN in the extended space to construct local and long-range connections within a single graph. A sequential graph neural network (GNN) based on the DeLA operator can process this graph without the need for an explicit multiresolution hierarchy. Validation includes graph structure analysis, classification and segmentation benchmarks, controlled graph ablation experiments, data distortion tests, and latency comparisons. The results demonstrate that, under the evaluation settings, this method not only achieves competitive accuracy but also improves robustness against sampling artifacts and reduces graph construction and inference costs.
Critical strengths
-
The idea of capturing continuous, multi-scale connectivity within a single graph is intriguing and offers an attractive alternative to explicit hierarchies.
-
The results are encouraging: in evaluation settings, the method demonstrated competitive accuracy, robustness to sampling artifacts, and reduced inference latency.
Critical weaknesses
-
The universality of the composition method has been verified only to a limited extent. The current implementation is primarily based on the DeLA operator. Although comparisons have been made with methods such as PTv2 and PTv3, cross-model comparisons cannot isolate the impact of the composition method. A controlled comparison of hierarchical connections versus Edge Soup connections in a different class of architectures would help confirm whether the benefits depend on specific operators.
-
The fairness and completeness of the speed comparisons still need to be improved. The authors acknowledge that PTv3 uses denser sampling and a less optimized preprocessing implementation; therefore, the latency difference cannot be entirely attributed to the removal of the hierarchical structure. Comparisons with DeLA should also match input size, operators, network depth, and channel width as closely as possible, and explain any remaining differences. It is recommended to supplement the analysis with peak GPU memory usage, as well as the time costs of key stages such as sampling, graph construction, spatial encoding, and feature aggregation.
-
An analysis of how the receptive field evolves with depth is lacking. Multi-layer message passing on a single graph also progressively expands the receptive field, whereas the existing analysis primarily consists of static graph statistics. Comparing the receptive field coverage and effective contribution distributions of standard k-NN, hierarchical architectures, and Edge Soup at different depths would help elucidate their multiscale information integration mechanisms.
Questions for authors
-
In the time-series experiments, how do Edge Soup and DeLA compare in terms of the number of input points, aggregation depth, and channel width? Can you provide a breakdown of runtime and peak memory usage to clarify the sources and costs of the performance gains?
-
Do the outdoor build times reported in the paper include the additional kNN queries and inverse density sampling described in Appendix B.4?
-
Equation (7) appears to imply , rather than Equation (6). Is this a typographical error? Which expression is used in the actual implementation?
The current inclination is to reject this paper; however, if the previous issues are properly addressed, I am inclined to accept it.
2 comments
Response to Review [2/2]: Revised Latency Results (Table 3), Questions 1 and 2
Revised latency results in Table 3
Multiple questions address Table 3. We include an updated version here, which we will also include in the paper. We address each change in a separate subsection.
PTv3 slowness
Prompted by the reviews, we investigated the PTv3 implementation and discovered a difference in the inference procedure of PTv3. This inflated its setup costs relative to ours and we fixed this. The updated results do not affect claims made in the paper.
Peak memory requirements
We additionally computed peak memory requirements and include these in the table.
nuscenes
| Model | Total Time (ms) | Constr. Time (ms) | Forward Time (ms) | Forward Peak MiB |
|---|---|---|---|---|
| PTv3 | 38.4 | 8.2 | 28.6 | 321 |
| Soup | 31.1 | 25.3 | 5.4 | 207 |
S3DIS
| Model | Total Time (ms) | Constr. Time (ms) | Forward Time (ms) | Forward Peak MiB |
|---|---|---|---|---|
| PTv3 | 325 | 232 | 63.6 | 1373 |
| DeLA | 178 | 165 | 12.9 | 609 |
| Soup | 128 | 107 | 20.4 | 818 |
ShapeNet
| Model | Total Time (ms) | Constr. Time (ms) | Forward Time (ms) | Forward Peak MiB |
|---|---|---|---|---|
| DeLA | 20.6 | 9.9 | 10.7 | 60 |
| Soup | 13.1 | 6.4 | 6.6 | 46 |
Cost of additional setup steps [Addressing Question 1 part 2, Question 2]
Depending on the dataset, building a soup graph requires additional steps compared to a NN; these are included in the "Constr. Time" step when measuring latency. The difference between the construction time of the Soup graph and NN graph shows the net additional cost of estimating density, re-ordering points, computing weights, and performing the 4d NN query.
This cost is largest on nuscenes, where construction time is increased by 70% (14.9ms vs 25.3ms) primarily due to inverse density sampling, which involves an extra NN-based density estimation step. On S3DIS, which uses random sampling, the gap is only 11% (96ms vs 107ms). On ShapeNet, where FPS is used, the gap is 40% (4.6ms vs 6.4ms).
PTv3 voxel sampling
The use of finer voxels and less efficient voxelization algorithm contribute to the high latency of PTv3. Using our voxelization approach cuts its S3DIS total from 325 to 198 ms without affecting behavior. Also adopting our larger voxels reaches 125 ms, comparable to Soup (128 ms), but gives a coarser input that should reduce accuracy.
DeLA (U-Net) configuration [Addressing Question 1 part 1]
When measuring latency, our re-implementation of DeLA uses the same settings as the original DeLA, whereas for our own model we use the configuration that achieves best accuracy on each task, as listed in Appendix A.3. Both configurations use the same input points.
Prompted by reviewer comments, we set up and time a version of the DeLA U-Net on S3DIS with parameters that more closely match the parameters of the Soup model. This configuration raises the number of convolutions from 20 to 24 (6 on each scale) and uses a constant width of 160 throughout, rather than increasing for coarser scales. This reduces its parameter count from 7M to 2.6M, similar to the soup model.
Despite its reduced size, the forward pass of the matched model is slightly slower than the original DeLA. We attribute this to its increased depth and wider convolutions on the finest scale. Both models remain slower than our model when accounting for graph construction time.
| Model | Total Time (ms) | Constr. Time (ms) | Forward Time (ms) | Forward Peak MiB |
|---|---|---|---|---|
| DeLA | 178 | 165 | 12.9 | 609 |
| DeLA-matched | 177 | 163 | 13.5 | 585 |
| Soup | 128 | 107 | 20.4 | 818 |
Response to Review [1/2]: Additional Experiments, Eq. (7) Correction
Thank you for your thorough review. We respond to the questions asked and the main weaknesses mentioned.
Generalization to alternative architectures
We test on DeLA for its low latency and memory use, our edge soup graph could be combined straightforwardly with many alternative architectures, as most message-passing approaches can operate on arbitrary input graphs. Our approach could also be applied to a linear attention model like PointTransformer v3, though such a conversion is more involved and beyond the scope of this submission.
For a cursory ablation, we configured small ResNets on ShapeNet with EdgeConv and PointNeXt trained for 25 epochs with the following results:
Alternative Convolutions on ShapeNet (mIoU)
These results indicate that the benefits of Soup edges can generalize beyond DeLA's convolutions.
Receptive field growth with model depth
Motivated by your feedback, we performed an experiment measuring how receptive field relates to model depth. We set up a point cloud uniformly distributed over a plane, and built a simple kNN graph (k=24) and a Soup graph (k=24, Q=4, coarse density 1/100th of base). The following table shows the number of nodes that contribute to a target node after n convolutions.
We observe that on the soup graph, receptive field grows more rapidly.
Equation (7) Error [Addressing Question 3]
Thank you for catching the inconsistency in equation (7). This was a transliteration error; the code actually uses the following expression:
\frac{ \rho_s }{ Q^{\frac{1}{d}} - 1 } = \frac{ Q^{-\frac{s}{d}} }{ Q^{\frac{1}{d}} - 1 } \rho_0$$ which satisfies a slightly different recurrence relation: $$w_s - w_{s+1} = \rho_{s+1}$$ This spaces nodes apart by the reach of the node on the _finer_ scale, rather than the coarser scale. We will ensure this is fixed in the paper.