acceptodds
Under review as a conference paper at ICLR 2027

Edge Soup: Continuous-Scale Point Cloud Learning with a Single Graph

Abstract

Point-cloud learning is dominated by hierarchical architectures that explicitly discretize geometric information into a fixed set of scales. We introduce Edge Soup, a graph construction method that instead models scale as a continuous property of nodes within a single graph. By assigning points a scale coordinate and performing a -nearest-neighbor query in an augmented space, we generate a homogeneous "soup" of edges that has connectivity ranging from local to long-range. The resulting graph reproduces structural characteristics of hierarchical representations while requiring only a single graph-construction step. A simple sequential Graph Neural Network (GNN) operating on this graph achieves competitive performance on challenging point-cloud segmentation benchmarks without the need for separate graphs or cross-scale connections like pooling and unpooling. Such a network exhibits increased robustness to density variation, noise, and sampling artifacts, maing it particularly effective on large-scale LiDAR datasets. Because Edge Soup replaces expensive hierarchy construction with a single graph building step, it substantially reduces data preparation overhead and lowers end-to-end inference latency on large point clouds.

Primary area:
learning on graphs and other geometries & topologies
Keywords:
Point Clouds, Graphs, Deep Learning

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_uEGQOpenReview ↗
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
  1. The idea of capturing continuous, multi-scale connectivity within a single graph is intriguing and offers an attractive alternative to explicit hierarchies.

  2. The results are encouraging: in evaluation settings, the method demonstrated competitive accuracy, robustness to sampling artifacts, and reduced inference latency.

Critical weaknesses
  1. 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.

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

  3. 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
  1. 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?

  2. Do the outdoor build times reported in the paper include the additional kNN queries and inverse density sampling described in Appendix B.4?

  3. Equation (7) appears to imply ws−ws+1=Q−2/dρsw_s-w_{s+1}=Q^{-2/d}\rho_s, 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
AuthorsOpenReview ↗

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)

GraphEdgeConvPointNeXt
Flat74.3 ± 1.076.1 ± 0.3
Soup75.5 ± 0.277.4 ± 0.6

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 kkNN graph (k=24k=24) and a Soup graph (k=24k=24, Q=4Q=4, coarse density 1/100th of base). The following table shows the number of nodes that contribute to a target node after nn convolutions.

# convs.kkNNSoup
4300453
812252264
1227629507
16482429626

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.
AuthorsOpenReview ↗

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

ModelTotal Time (ms)Constr. Time (ms)Forward Time (ms)Forward Peak MiB
PTv338.48.228.6321
Soup31.125.35.4207

S3DIS

ModelTotal Time (ms)Constr. Time (ms)Forward Time (ms)Forward Peak MiB
PTv332523263.61373
DeLA17816512.9609
Soup12810720.4818

ShapeNet

ModelTotal Time (ms)Constr. Time (ms)Forward Time (ms)Forward Peak MiB
DeLA20.69.910.760
Soup13.16.46.646

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 kkNN; these are included in the "Constr. Time" step when measuring latency. The difference between the construction time of the Soup graph and kkNN graph shows the net additional cost of estimating density, re-ordering points, computing weights, and performing the 4d kkNN 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 kkNN-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.

ModelTotal Time (ms)Constr. Time (ms)Forward Time (ms)Forward Peak MiB
DeLA17816512.9609
DeLA-matched17716313.5585
Soup12810720.4818
Reviewer_tWTuOpenReview ↗
Rating
4
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper proposes Edge Soup, a graph construction method with a single graph rather than hierarchical multiscale graphs for point cloud learning. Experimental results demonstrate that this method can segment point cloud very fast with state-of-art accuracy. The advantage is more obvious for segmenting a large point cloud.

Critical strengths
  • The proposed graph construction is simple and interesting. It can extract multi-scale features without explicit hierarchical graphs.
  • This paper validated the performance of the proposed method on extensive experiments.
  • Compared to benchmark methods in Outdoor Scene Segmentation Tasks, the proposed method can achieve similar accuracy with 1/30 parameters, which can reduce the inference cost significantly.
Critical weaknesses
  • Although the proposed continuous-scale graph construction method is interesting, there are some similar ideas in previous works, such as Point-GNN. It is better for this paper to clarify the novel against these similar works.
Questions for authors
  • Could the authors further clarify the novelty of Edge Soup compared with previous single-graph point-cloud learning methods, such as Point-GNN? Since they are designed for different tasks: segmentation VS object detection, it is not required to compare them in experiments. It is enough to just compare with these methods theoretically.
  • Since each GNN layer needs to process the full graph, will it cause higher GPU memory usage compared to hierarchical methods?
1 comment
AuthorsOpenReview ↗

Response to Review: Comparison to Point-GNN and Memory Cost Analysis

Thank you for your review. We respond to the questions asked and the two main weaknesses mentioned.

Comparison to single-graph approaches, Point-GNN

Our edge soup graph combines connections over a continuous range of scales in a single graph. Point-GNN does not combine multiple scales in a single graph, but instead uses a PointNet++-like radius graph in 3d with a single fixed radius (see eq. 1 in Point-GNN paper). We will add a discussion comparing our approach to Point-GNN and other single-graph approaches.

Memory requirement of all points participating in convolutions

Unlike on a typical U-Net, the entire point cloud is included in all layers of the network. The most memory-intensive stages of the DeLA U-Net are the first layer 'spatial encoder' and the final segmentation head. These components are shared between our model and DeLA.

We compare the computational and memory costs to the 'traditional' hierarchy in DeLA in the following table. Our best models require more memory than the base U-Net, but still well below PointTransformer v3.

Peak GPU memory during forward pass (MiB)

ModelnuscenesS3DISShapeNet
PTv33211373-
DeLA-60960
Soup20781846
Reviewer_YSuaOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
1
Read review
Paper summary

This paper proposes Edge Soup, a point cloud learning method based on a single graph structure. The method assigns a continuous scale to each point in the point cloud according to a predefined strategy, and then performs a single KNN search in a four-dimensional space consisting of the original 3D coordinates and the assigned scale to construct a fixed graph covering the entire point cloud. The goal is to reduce the overhead associated with repeatedly performing downsampling, KNN searches, and graph construction at different layers in traditional hierarchical point cloud networks.

Critical strengths

The proposed point-wise continuous-scale assignment assigns a continuous scale to each point, allowing points at different scales to be represented within a unified graph. Since the quality of scale assignment may directly affect model performance, the paper investigates this design choice quite comprehensively, considering multiple strategies, including random assignment, farthest point sampling (FPS), and inverse-density-based ordering.

Critical weaknesses

Although the proposed method reduces the number of neighborhood construction operations, it requires performing a four-dimensional KNN search over all input points and storing the resulting graph. For large-scale point clouds, this step may incur substantial computational overhead and peak memory consumption. Therefore, reducing the number of KNN searches alone is insufficient to demonstrate the overall efficiency gains of the proposed method. The authors are encouraged to report graph construction time, end-to-end runtime

Questions for authors

The method requires performing a four-dimensional KNN search over all input points and storing the resulting graph. How do the computational and memory costs of KNN search and graph storage scale as the number of points increases? Have the authors considered potential peak memory issues when processing large-scale point clouds? It is recommended that the authors report graph construction time, peak GPU memory consumption, and the maximum number of points that the method can handle at different input sizes. Traditional hierarchical point cloud networks reduce the number of query points through progressive downsampling and aggregate neighborhood features only for the query points retained at each layer. In contrast, does Edge Soup perform feature aggregation over all points in every network block? If all points participate in feature aggregation across multiple network blocks, how do the associated computational and memory costs compare with those of traditional hierarchical methods? Can the single-graph construction and continuous-scale assignment be applied to other point cloud backbone networks?

1 comment
AuthorsOpenReview ↗

Response to Review: Computational Cost and Generalization Experiments

Thank you for your review. We respond to the questions asked and two main weaknesses mentioned.

Computation cost of 4d kkNN over 3d

We find that the 4d kkNN search is only marginally slower than 3d kkNN on real data (14.4s vs. 13.7s). The cost of kkNN computation in 4d depends on the distribution of points in the fourth dimension. In our setting, most points are close together in the fourth dimension because of how wsiw_{s_i} is defined, with only a small fraction of coarse points as outliers. For comparison, when points are uniformly distributed in the fourth dimension, 4d kkNN takes nearly 60% longer than 3d (21.6s vs. 13.7s).

We use a kd-Tree algorithm (pynanoflann) for kkNN queries on large point clouds. This algorithm has complexity on the order of O(nlogn)O(nlogn) and linear memory requirements. Here, we evaluate its performance on the largest room of S3DIS (Auditorium, 7.06 M points).

Input PointsTime (s)Peak memory (MiB)
3d13.73435
4d (Uniform weights)21.63462
4d (Soup weights, ours)14.43465

Computation cost of all points participating in convolutions

Unlike on a typical U-Net, the entire point cloud is included in all layers of the network. We alleviate the performance implications by using the same width throughout the network rather than progressively wider convolutions, and by using the inexpensive convolution operator from DeLA. DeLA's most expensive stage is the first layer 'spatial encoder', which must operate on all nodes both in the U-Net and in our architecture.

We compare the computational and memory costs to the 'traditional' hierarchy in DeLA in the following table. This shows that Soup is faster in total inference time, due to the sped-up construction time.

S3DIS

ModelTotal Time (ms)Constr. Time (ms)Forward Time (ms)Forward Peak MiB
DeLA17816512.9609
Soup12810720.4818

ShapeNet

ModelTotal Time (ms)Constr. Time (ms)Forward Time (ms)Forward Peak MiB
DeLA20.69.910.760
Soup13.16.46.646

Generalization to alternative architectures

Our edge soup graph could be combined straightforwardly with many alternative architectures, as most message-passing approaches can operate on arbitrary input graphs.

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)

GraphEdgeConvPointNeXT
Flat74.3 ± 1.076.1 ± 0.3
Soup75.5 ± 0.277.4 ± 0.6

These results indicate that the benefits of Soup edges generalize beyond DeLA's convolutions.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.