acceptodds
Under review as a conference paper at ICLR 2027

Many Steps, One Pass: Latent Trajectory Simulation for Efficient LiDAR Scene Completion

Abstract

Diffusion-based LiDAR scene completion unlocks the potential to transform sparse scans into rich, detailed 3D geometry. However, traditional iterative denoising requires invoking the full denoising backbone at every step, burdening inference with substantial computational cost. While some distillation methods aims to streamline this process, most of which reduces the nuanced evolution of reconstruction to a single endpoint, discarding the valuable intermediate states. To achieve a better trade-off between accuracy and efficiency, we introduce LiTE (LiDAR Trajectory Evolution), which performs multiple teacher-aligned latent updates at a deep feature interface within each student transition, decoupling internal geometric evolution from repeated full-backbone evaluation. Within this framework, we propose Visibility-Conditioned Latent Transport (VCLT) to execute these latent updates while maintaining robust local scan conditioning as the trajectory unfolds; it dynamically updates scan-to-point correspondences at the feature level and leverages sensor-ray visibility to precisely guide geometric refinement. Comprehensive experiments on SemanticKITTI and KITTI-360 shows that LiTE achieves state-of-the-art Chamfer distance and JSD, while delivers an inference speedup over the 50-step LiDiff teacher and improvement over 8-step ScoreLiDAR.

Primary area:
generative models
Keywords:
LiDAR scene completion, Diffusion acceleration, Trajectory distillation, Efficient inference, 3D point cloud generation, Autonomous driving perception

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_KDhKOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes LiTE (LiDAR Trajectory Evolution), a distillation framework for accelerating diffusion-based LiDAR scene completion. LiTE inserts Visibility-Conditioned Latent Transport (VCLT) at a deep sparse U-Net interface and executes several teacher-aligned latent micro-steps within one encoder-decoder pass. VCLT repeatedly updates scan-to-query correspondences, combines a global motion field with local scan guidance, and gates the local contribution using sensor-ray visibility. Training combines EMA endpoint consistency, direct supervision from LiDiff trajectories, intermediate latent-trajectory losses, and terminal structural losses. On various datasets, the four-transition model improves completion metrics over baselines while reporting substantially lower latency.

Critical strengths
  1. The method addresses an important computational bottleneck with a coherent LiDAR-specific design. Decoupling expensive sparse U-Net evaluations from lightweight internal trajectory updates is well motivated.

  2. The paper reports useful technical details and diagnostics. The appendix specifies the endpoint, intermediate trajectory, free-space, occupancy/density, and local-geometry objectives. Raw and refined outputs are separated, several inference depths are evaluated with one checkpoint, and the paper reports local ray-class diagnostics and the isolated cost of the conditioning component rather than relying only on a single headline result.

Critical weaknesses
  1. Lack of baseline comparisons and discussions. LiNeXt (2511.10209), LiFlow (2602.02232, RapidLiDAR (2608.16490), etc., are competitive baselines. The relevant methods should be discussed and, ideally, implement under the paper's common protocol for fair comparison.
  2. The ablations do not isolate the mechanisms used to justify the central novelty. E.g., replacing VCLT with radius attention or closest-point matching simultaneously removes dynamic coordinate transport and visibility routing while changing module placement and aggregation; as acknowledged in the appendix, this comparison does not separately establish the benefit of visibility.
  3. Several concerns about the efficiency claim. Considering deployment, the current statement of inference efficiency seems insufficient. Besides, the statement that LiTE is trained on only 5.2% of LiDiff's training set should not be interpreted as end-to-end data efficiency because the student relies on a LiDiff teacher that was itself trained on the full dataset.
Questions for authors
  1. Within VCLT, what are the independent contributions of dynamic candidate refresh, ray-visibility routing, the global motion field, GRU history, and free-space supervision?
  2. How sensitive is the method to the number and spatial resolution of latent queries? What happens when initially assigned queries cross or move far from their original lattice cells? Was dynamic particle-to-query reassignment tested?
  3. I would like to see some more comparisons to recent related works such as LiFlow or RapidLiDAR as mentioned above.
  4. Can the authors provide a parameter- and compute-matched control to show that the gain comes from teacher-aligned latent trajectory supervision rather than additional recurrent depth or model capacity?
  5. I'm also quite concern the efficency regarding deployment online. Could you clarify the latency protocol, including whether one sample uses one or four GPUs, batch size, warm-up, synchronization, preprocessing, data transfer, and refinement? Any detailed inference protocal would be helpful.
5 comments
AuthorsOpenReview ↗

Response to Reviewer KDhK

We thank the reviewer for the detailed questions on deployment and on the latent queries. Note: this reply refers to Table R1 (General Comment, Part 1), Tables R2–R3 (General Comment, Part 2), and Table R4 (General Comment, Part 3); please see these comments for the full tables.

W1 / Q3: LiNeXt, LiFlow, and RapidLiDAR. Following the reviewer's suggestion, we evaluated all three methods from their public weights under our common protocol with the same refiner, which confirms the comparison in Table R2 and also provides IoU for RapidLiDAR. LiNeXt and RapidLiDAR outperform LiTE (CD† 0.149 and 0.138 vs. 0.283). However, they address a different problem: they are regression networks that predict the completed scene in a single forward pass, with no diffusion process involved. LiTE is a distillation method: given a pretrained generative teacher, it trains a few-step student from only 1,000 scans without retraining the generative model, and among distillation methods it achieves the best CD and JSD with a quarter of the backbone evaluations (Table R2). As shown in Table R2, LiFlow has lower CD than LiTE (CD† 0.228 vs. 0.283), while LiTE is better on JSD (JSD† 0.361 vs. 0.367) and fine-scale IoU (IoU† at 0.2 / 0.1 m: 25.81 / 13.67 vs. 25.1 / 12.9). Being a generative model, LiFlow can also serve as a stronger teacher for LiTE, so we distilled it: the four-step student surpasses LiFlow itself on every refined metric while denoising 2.9× faster (Table R3).

W2 / Q1: Independent contributions inside VCLT. We agree that replacing VCLT with Radius Attention or Closest Point removes several components at once. The five components map to single-factor controls in Table R4 (full model: CD† 0.283, JSD† 0.361, IoU† 0.1 m 13.67):

ComponentControlCD†JSD†IoU† 0.1 m
Dynamic candidate refreshD2: frozen candidates0.2870.36713.02
Ray-visibility routingD1: γ ≡ 1, no ray features0.2910.36412.46
Global motion fieldD3: g removed0.2930.37112.63
GRU historyD4: parameter-matched MLP0.3640.38111.09
Free-space supervisionD5: loss removed0.3060.37912.69

Each component contributes beyond seed variance, with GRU history and free-space supervision mattering most.

W3: Efficiency and the 5.2% claim. As corrected in Table R1, LiTE is 2.8× faster than ScoreLiDAR in denoising (2.3× when averaged over frames) and 1.4× faster end-to-end. On data, we agree that 5.2% should not be read as end-to-end data efficiency, since the teacher was trained on the full dataset. What it does reflect is how lightly LiTE uses the teacher: unlike ScoreLiDAR, whose student is initialized from LiDiff weights and queries the teacher throughout training, LiTE is trained from random initialization and uses the teacher only offline, to generate trajectories for 1,000 scans. The revised paper describes 5.2% as the data budget of the distillation stage.

Q2: Latent queries. The queries are the occupied sites at the deep interface of the U-Net, so their number and resolution follow from the backbone stage rather than a free hyperparameter. At inference there is no particle-to-query correspondence. A query's position is only a lookup point: at every micro-step, scan candidates and visibility are retrieved again from its current position, while its hidden state stays on its own lattice site and is decoded there. A query that moves far from its cell therefore simply reads evidence from its new location without causing any mismatch. The assignment π(n) is used only during training to build supervision targets; dynamic reassignment would change only these targets.

Q4: Parameter- and compute-matched control. Row C1 in Table R4 is this control: the same architecture, micro-steps, parameters (33.70 M), and inference time as the full model, with only the teacher-aligned supervision removed. CD† degrades from 0.283 to 0.473, so the gain does not come from recurrent depth or capacity. VCLT itself adds only 0.30 M parameters.

Q5: Latency protocol for online deployment. Each frame uses one GPU (not four) with batch size 1, and torch.cuda.synchronize() is called around every timed segment; baseline times are single runs without a separate warm-up, and LiTE's denoising time is the per-frame mean over sequence 08. End-to-end time includes filtering, CPU FPS, host-to-GPU transfer, and post-processing; disk reading is excluded, and the shared refiner adds 0.09 s for every method. For online deployment, the CPU FPS inherited from the LiDiff protocol now dominates (2.97 s of 3.93 s), so the system is not yet real-time; we have added this as a limitation, and removing it requires training with a cheaper sampler.

AuthorsOpenReview ↗

Follow-up to Reviewer KDhK

Dear Reviewer KDhK,

Thank you once more for your thoughtful comments, especially on deployment efficiency and the behavior of the latent queries. Since the discussion period will close soon, we would like to gently follow up on our response.

Following your suggestions, we evaluated LiNeXt, RapidLiDAR, and LiFlow under a common protocol and showed that LiTE can distill LiFlow into a stronger four-step student. We also isolated each VCLT component, provided a parameter- and compute-matched control, detailed the full latency protocol, clarified the scope of the 5.2% claim, and explained why moving queries do not cause a mismatch at inference. We believe these cover all the points in your review.

We would greatly appreciate your thoughts on whether these responses address your concerns. If there are further questions or experiments you would find helpful, we would be glad to discuss them before the deadline.

Best regards, The Authors

Reviewer_KDhKOpenReview ↗

Opioions on the first round of replies

Thank you for the additional experiments and clarifications. The new ablations address much of my concern about mechanism attribution, and I appreciate the corrections to the efficiency and performance claims.

However, these results also suggest a narrower contribution than originally presented. The end-to-end speedup is modest, and the accuracy advantage is limited to the compared distillation methods. For now I decide to keep my initial rating.

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

This paper proposes LiTE, a framework for distilling LiDiff into a few-step LiDAR scene completion model. It performs recurrent updates of sparse query positions and hidden states within a deep U-Net interface, using teacher intermediate point clouds for supervision. A visibility-conditioned matching mechanism guides these updates, while the encoder and decoder are evaluated only once per outer transition. Experiments on SemanticKITTI and KITTI-360 report improved completion quality and reduced inference latency.

Critical strengths

-The use of a GRU to propagate trajectory history during internal query updates is an interesting design. It offers a way to retain intermediate geometric evolution while reducing full backbone evaluations, providing a useful perspective on accelerating diffusion-based point cloud completion. -The reported results show a promising quality-efficiency trade-off across two datasets. Reporting both raw and refined outputs, together with comparisons at different inference depths, helps assess the method's behavior.

Critical weaknesses

-The source of the substantial speedup is not sufficiently explained. Reducing full network evaluations from eight to four does not by itself explain the reported 5.9x speedup over ScoreLiDAR. Large latency differences also remain at matched inference depths. The local conditioning timings account for only part of the overall gap, leaving unclear how much of the gain comes from the proposed mechanism versus differences in network configuration or implementation. -The contributions of the core mechanism and the complex supervision are not sufficiently isolated. The objective combines EMA endpoint consistency, direct teacher supervision, intermediate position and direction losses, a free-space constraint, and several structural losses. The ablations largely remove groups of terms, while the direct-path comparison changes both the transition parameterization and EMA consistency. These comparisons do not isolate the benefit of internal trajectory updates or establish the necessity of the individual supervision terms. -The presentation also needs clarification. The relationship between internal query updates, the intermediate point clouds constructed for supervision, and the decoder output takes considerable effort to follow. The notation in Figure 3 mixes correspondence mappings, approximate equalities, and addition. The scene illustrations in Figures 2 and 3 have a schematic rendering style; their provenance and illustrative status should be stated explicitly. Real SemanticKITTI point clouds with matched views of the input, prediction, and ground truth would make the explanation more concrete.

Questions for authors

1.Please provide a component-level latency breakdown explaining the substantial gap between LiTE and ScoreLiDAR at matched inference depths. Please specify the GPU count used per input frame, batch size, timing boundaries, and whether backbone size and point counts are matched. 2.Is the student initialized from LiDiff weights, and which parameters are frozen or updated? Does the claim of using only 5.2% of the training data refer exclusively to the student distillation stage? Please report the costs of teacher trajectory generation and student training separately. 3.With the backbone, loss configuration, and training budget held fixed, what are the separate contributions of recurrent internal updates, teacher intermediate-state supervision, and visibility conditioning? Can a simpler supervision configuration achieve comparable performance?

3 comments
AuthorsOpenReview ↗

Response to Reviewer Xdt9

We thank the reviewer for the detailed questions on latency, which uncovered an error in our speedup claim. Note: this reply refers to Table R1 (General Comment, Part 1) and Table R4 (General Comment, Part 3); please see these comments for the full tables.

W1 / Q1: Source of the speedup and component-level latency. The reviewer is right that halving the steps cannot explain the reported speedup; it was measured inconsistently, and the correction is in Table R1 of our general comment. The component breakdown is:

Component (s)ScoreLiDAR, 8 stepsLiTE, 4 steps
Preprocessing (filtering, CPU FPS) and post-processing2.972.97
Denoising2.70 (16 backbone evals)0.96 (4 backbone evals + VCLT)
Total5.673.93

Each frame uses one GPU with batch size 1; the four GPUs in Appendix E were used only for training, which we have clarified. Timing runs from the loaded scan to the output point cloud, with the shared refiner reported separately. The backbones are matched (33.70 M vs. 32.67 M with the same encoder; VCLT adds 0.30 M), and both methods use the same 18,000-point input and output size. Table 4 isolates only the local-conditioning operators, and its caption now says so.

At matched depths, with the same preprocessing on both sides:

Steps1248
ScoreLiDAR denoising / total (s)0.55 / 3.520.87 / 3.841.46 / 4.432.70 / 5.67
LiTE denoising / total (s)0.58 / 3.550.67 / 3.640.96 / 3.931.57 / 4.54
Denoising speedup0.9×1.3×1.5×1.7×
ScoreLiDAR / LiTE CD†0.548 / 0.3120.403 / 0.2880.326 / 0.2830.342 / 0.275

The large matched-depth gap in the original Table 6 came from the same error, and we have corrected it. The denoising speedup grows with the number of steps, from 1.3× at two steps to 1.7× at eight, while at a single step the two are on par, since the VCLT micro-steps add a roughly fixed cost. In quality, LiTE is better at every depth, and one-step LiTE already reaches a lower CD† than eight-step ScoreLiDAR.

W2 / Q3: Separate contributions and simpler supervision. Table R4 answers this. Rows B2 and B3 separate the parameterization from EMA agreement: the parameterization accounts for most of the difference (CD† 0.296 vs. 0.385), and EMA agreement adds a smaller gain. Removing teacher intermediate-state supervision (C1, CD† 0.473) or reducing internal evolution to one update per transition (C3, 0.417) hurts most; disabling visibility has a smaller effect (D1, 0.291). Structural losses can be removed at little cost (E6, 0.292), but the minimal supervision is clearly worse (E7, 0.343).

W3: Presentation. We have added a paragraph explaining how the three objects relate: internal queries are updated within a transition, intermediate point clouds are built only during training for comparison with teacher states, and the decoder runs once per transition on the final latent state. Figure 3 now uses distinct symbols for correspondence, approximation, and addition. We thank the reviewer for the suggestion on the scene illustrations: the schematic scenes in Figures 2 and 3 have been replaced with real SemanticKITTI point clouds, showing input, prediction, and ground truth from matched views.

Q2: Initialization, data, and cost. The student is randomly initialized, not from LiDiff weights; all its parameters are trained, and only the EMA target receives no gradients. It is trained for 20 epochs. The 5.2% refers only to this distillation stage, which the revised paper now states explicitly. Student training takes 5.8 hours on 4 GPUs (about 23 GPU-hours), and generating teacher trajectories for the 1,000 training scans takes about 4.1 GPU-hours. The LiDiff teacher is used as released.

AuthorsOpenReview ↗

Follow-up to Reviewer Xdt9

Dear Reviewer Xdt9,

We remain grateful for your careful questions on latency, which led us to identify and correct the error in our reported speedup. With the discussion deadline approaching, we wanted to check in on our response.

To summarize, we provided a component-level latency breakdown under one consistent protocol, together with matched-depth timings, and corrected the speedup accordingly. We also separated the contributions of recurrent updates, teacher supervision, and visibility with single-factor ablations, reported initialization and training costs, and revised the figures with real SemanticKITTI point clouds. We hope these fully address your comments.

Your feedback on whether the corrected analysis resolves your concerns would mean a great deal to us. We would also be happy to clarify any remaining questions in the time left.

Best regards, The Authors

AuthorsOpenReview ↗

Reminder to Reviewer Xdt9

Dear Reviewer Xdt9,

We hope this message finds you well. As the discussion period is about to close, we would like to kindly follow up once more on our response.

Your questions on latency were the starting point for the main correction in our revision: the speedup is now reported under one consistent protocol with a component-level breakdown (Table 2), together with matched-depth timings (Table 12). The revision also adds 15 single-factor ablations separating recurrent updates, teacher supervision, and visibility (Table 14), and replaces the schematic scenes in Figures 2 and 3 with real point clouds, as you suggested. All changes are marked in blue in the uploaded PDF.

We would greatly appreciate even a brief note on whether these changes resolve your concerns, or on anything that remains unclear. We would be glad to respond right away.

Thank you again for your time and careful review.

Best regards, The Authors

Reviewer_jDykOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
3(+1)
Read review
Paper summary

This paper proposes LiTE, a distillation framework for LiDAR scene completion. The method uses pre trained LiDiff as the teacher to perform multiple latent state updates within one outer layer transition of the student network, simulating the teacher's multi-step denoising trajectory with fewer complete backbone network calculations. The core module VCLT dynamically updates observation matching based on potential query locations and adjusts local and global conditions using the visibility information of sensor rays. Training combines transfer consistency, teacher intermediate trajectory supervision, and terminal structure constraints. The paper evaluated the method on SemanticKITTI and KITTI-360 and used the same student model to support different inference steps. The results showed that compared to the teacher model and distillation baseline compared in the article, LiTE achieved a good balance between completion quality and inference time.

Critical strengths
  1. The design addresses a concrete challenge in low-step geometric completion. As generated points move during a long transition, their spatial relationships with the observed scan change. LiTE explicitly accounts for this through latent updates, refreshed scan associations, and visibility-dependent conditioning. I find this a well-motivated direction for retaining geometric information while reducing full-backbone evaluations.

  2. The complete system shows meaningful empirical improvements. The paper reports results across two datasets and multiple inference depths, with raw and refined outputs evaluated separately. For example, on SemanticKITTI, four-step LiTE achieves a refined CD of 0.283 in 1.045 seconds, compared with 0.326 in 4.540 seconds for four-step ScoreLiDAR. These results, together with evaluation of the same checkpoint on KITTI-360, support the practical value of the approach.

Critical weaknesses
  1. The comparison with directly related distillation methods is incomplete, and the broader performance claims need clearer support. ScoreLiDAR is an appropriate baseline, but Distillation-DPO, which also studies LiDiff-based distillation for LiDAR completion, is missing from the comparison. This limits the evidence for the proposed student design relative to a closely related alternative. Separately, the abstract’s state-of-the-art CD and JSD claims need to be positioned against recent scene completion methods such as LiNeXt, LiFlow, and PatchScene, with appropriate attention to differences in input conditions, spatial extent, output density, and evaluation protocols. These comparisons serve different purposes: Distillation-DPO is directly relevant to the distillation contribution, whereas the other methods help establish the broader competitiveness of the resulting completion system. Where a fair comparison is not feasible, the relevant differences should be explained and the performance claims qualified accordingly.

  2. The ablations do not yet isolate the contribution of the central new mechanisms. The main claim concerns teacher-aligned internal trajectory simulation and visibility-conditioned transport. However, the direct-path comparison in Table 2 changes both the transition parameterization and the EMA consistency objective. The conditioning alternatives in Table 3 and Appendix G also differ in query updates, visibility routing, and feature processing. These experiments support the complete design, but leave open how much of the improvement specifically comes from intermediate teacher supervision, as opposed to the existing consistency formulation or more general recurrent refinement. This uncertainty matters because teacher-aligned internal evolution is central to the paper’s contribution.

Questions for authors
  1. Can the contribution of teacher-aligned internal evolution be isolated more directly? With the transition parameterization, EMA objective, recurrent student architecture, and terminal losses held fixed, what happens when intermediate teacher-state supervision is removed? Separately, what happens when visibility routing is disabled while retaining the latent updates and matching mechanism? These controls would help establish whether the proposed supervision and visibility information each provide benefits beyond the underlying recurrent computation.

  2. How does LiTE compare with Distillation-DPO under a comparable protocol? A comparison using matched teacher, input/ground-truth construction, output point count, refinement, and timing conditions would help assess the method’s relative value. Please also clarify the actual number of backbone evaluations, classifier-free guidance settings, and reuse of conditioning features for LiTE and the distillation baselines. Equal outer-step counts do not necessarily imply equal computation; these details would help explain the measured speedup.

  3. The abstract claims state-of-the-art CD and JSD, but recent methods such as LiNeXt, LiFlow are not included in the comparison. How does LiTE compare with these methods under a comparable evaluation protocol?

4 comments
AuthorsOpenReview ↗

Response to Reviewer jDyk

We thank the reviewer for the careful assessment. Note: this reply refers to Table R1 (General Comment, Part 1), Tables R2–R3 (General Comment, Part 2), and Table R4 (General Comment, Part 3); please see these comments for the full tables.

W1 / Q2: Distillation-DPO and configuration details. As shown in Table R2 of our general comment, LiTE outperforms Distillation-DPO (CD† 0.283 vs. 0.354, JSD† 0.361 vs. 0.387) with 4 instead of 16 backbone evaluations. Both distill the same LiDiff teacher under the LiDiff protocol and refiner. The configurations, taken from the official code, are:

MethodStepsCFGBackbone evalsParams (M)Conditioning features
LiDiff50w = 6.010032.67re-encoded at every evaluation
ScoreLiDAR8w = 3.51632.67re-encoded at every evaluation
Distillation-DPO8w = 3.51632.67re-encoded at every evaluation
LiTE4none433.70encoded once per transition

We also measured Distillation-DPO under the same timing protocol (Table R1 in our general comment): its denoising takes 2.93 s against 0.96 s for LiTE, and its full pipeline 5.90 s against 3.93 s. The reviewer is right that equal outer steps do not imply equal computation; this is exactly where our original speedup went wrong.

W1 / Q3: The state-of-the-art claim; LiNeXt, LiFlow, and PatchScene. We agree and have removed the unqualified claim. We did not evaluate PatchScene because its protocol is entirely different: it is a voxel-based model whose output is a dense voxel grid of about 900k points rather than a point cloud of about 180k points, and its metrics are computed on these dense outputs, so a comparison under our point-cloud protocol would not be meaningful; we discuss it in the related work of the revised paper. For LiNeXt and LiFlow, following the reviewer's suggestion, we evaluated them from their public weights under a common protocol with the same refiner, which confirms the comparison in Table R2. LiNeXt outperforms LiTE (CD† 0.149 vs. 0.283). However, it addresses a different problem: it is a regression network that predicts the completed scene in a single forward pass, with no diffusion process involved. LiTE is a distillation method: given a pretrained generative teacher, it trains a few-step student from only 1,000 scans without retraining the generative model, and among distillation methods it achieves the best CD and JSD with a quarter of the backbone evaluations (Table R2). As shown in Table R2, LiFlow has lower CD than LiTE (CD† 0.228 vs. 0.283), while LiTE is better on JSD (JSD† 0.361 vs. 0.367) and fine-scale IoU (IoU† at 0.2 / 0.1 m: 25.81 / 13.67 vs. 25.1 / 12.9). Being a generative model, LiFlow can also serve as a stronger teacher for LiTE, so we distilled it: the four-step student surpasses LiFlow itself on every refined metric while denoising 2.9× faster (Table R3).

W2 / Q1: Isolating teacher-aligned evolution and visibility. Both controls are in Table R4. Removing intermediate teacher-state supervision with everything else fixed (C1) raises CD† from 0.283 to 0.473. Disabling visibility routing while keeping latent updates and matching (D1) gives CD† 0.291, a smaller but consistent effect. Rows B2 and B3 separate the parameterization from EMA agreement: the parameterization accounts for most of the difference (CD† 0.296 vs. 0.385 without EMA agreement), and EMA agreement adds a smaller gain under both. We have also clarified that the direct path in Table 2 contains VCLT.

AuthorsOpenReview ↗

Follow-up to Reviewer jDyk

Dear Reviewer jDyk,

Thank you again for your detailed review, which helped us sharpen both the comparisons and the ablations. As the discussion period is coming to an end, we would like to briefly follow up.

In our response, we compared LiTE with Distillation-DPO under the same teacher and protocol, reported the backbone evaluations, guidance settings, and feature reuse of all distillation baselines, withdrew the unqualified state-of-the-art claim, and added the two controls you asked for: removing intermediate teacher-state supervision (C1) and disabling visibility routing (D1). We believe these address the points raised in your review.

We would be very grateful to hear whether our response resolves your concerns. If anything remains unclear, or if there is any further analysis you would like to see, we would be happy to provide it before the deadline.

Best regards, The Authors

Thank you for the detailed explanations, which have resolved most of my concerns. I hope the authors can add reasonable supplementary discussions in the final draft to better highlight the contributions of this work.

My rating has been temporarily updated.

AuthorsOpenReview ↗

Reply to Reviewer jDyk

Dear Reviewer jDyk,

Thank you very much for your positive feedback and for updating your rating. We are glad that our explanations resolved most of your concerns.

Following your suggestion, we have uploaded a revised PDF in which all changes are marked in blue. The revision incorporates the discussions from the rebuttal into both the main text and the appendix: the positioning of LiTE as a teacher-based trajectory distillation framework with comparisons to Distillation-DPO, LiFlow, LiNeXt, and RapidLiDAR (Section 3.2, Table 3, and Appendix H), the single-factor isolation ablations (Section 3.3 and Appendix I), and the corrected latency analysis (Table 2 and Appendix G).

We sincerely appreciate your time and constructive comments, which have helped us improve the paper. We would be happy to address any remaining questions.

Best regards, The Authors

Comments on the paper

4 comments
AuthorsOpenReview ↗

General Comment, Part 1 of 3 (to all reviewers)

We thank all reviewers for their careful and constructive feedback. Three concerns are shared across the reviews, and we address each in a separate general comment: the reported speedup (Part 1, Table R1), the comparison with recent methods (Part 2, Tables R2–R3), and the isolation of our core mechanisms (Part 3, Table R4). We have revised the paper accordingly, and our replies to individual reviewers refer to these tables.

1. Correcting the speedup

We must first correct an error. The speedup over ScoreLiDAR reported in the original submission was measured inconsistently: ScoreLiDAR's full-pipeline time (5.67 s), which includes CPU farthest-point-sampling (FPS) preprocessing, was compared with LiTE's denoising-only time (0.96 s), although both methods use identical preprocessing. We apologize for this mistake.

Table R1 splits the same measurements into components under one consistent accounting (one NVIDIA H800, batch size 1, single-frame inference, GPU-synchronized timing). LiTE's 0.96 s is unchanged; only the comparison was wrong.

Table R1. Latency breakdown on SemanticKITTI (seconds per frame).

MethodStepsCFGBackbone evalsPre/post-processingDenoisingTotal
LiDiff50w = 6.01002.9714.7417.71
LiDPM20w = 6.0405.167.1912.35
ScoreLiDAR8w = 3.5162.972.705.67
Distillation-DPO8w = 3.5162.972.935.90
LiTE4none4 (+ 50 VCLT micro-steps)2.970.963.93

With consistent accounting, LiTE is 2.8× faster than ScoreLiDAR in denoising (2.3× when averaged over frames) and 1.4× faster end-to-end. The gain comes from computation rather than implementation: all methods share the same backbone, ScoreLiDAR needs two backbone passes per step for guidance, and LiTE needs one pass per transition plus lightweight VCLT micro-steps. We have corrected the speedup throughout the revised paper, now report denoising and end-to-end time side by side, and discuss the CPU preprocessing cost as a limitation.

AuthorsOpenReview ↗

General Comment, Part 2 of 3 (to all reviewers)

2. The State-of-the-Art Claim and Our Positioning

We apologize for the unqualified "state-of-the-art CD and JSD" statement in the original submission and have removed it. LiTE is a teacher-based trajectory distillation framework, rather than a standalone completion model trained from scratch: it distills a pretrained generative teacher into a four-step student, using only 1,000 scans (5.2% of the SemanticKITTI training scans) for student training. Table R2 compares recent methods across paradigms.

Table R2. Comparison on SemanticKITTI sequence 08 († = refined). CD and BEV-JSD are as reported in the respective papers; unreported IoU values are evaluated by us.

MethodParadigmFull-backbone evalsCD ↓CD† ↓BEV-JSD ↓BEV-JSD† ↓IoU† 0.5 / 0.2 / 0.1
LiTEDiffusion distillation4 (+50 VCLT micro-steps)0.3590.2830.3950.36136.82 / 25.81 / 13.67
ScoreLiDARDiffusion distillation160.4060.3420.4250.39937.37 / 23.45 / 10.76
Distillation-DPODiffusion distillation160.4140.3540.4190.38736.35 / 24.13 / 11.83
LiFlowFlow matching180.3090.2280.4160.36737.2 / 25.1 / 12.9
LiNeXtDirect reconstruction10.2140.1490.3360.33141.97 / 31.25 / 15.09
RapidLiDARDirect reconstruction10.2060.1380.3320.33041.82 / 31.10 / 15.86

Full-backbone evaluations include both guidance branches and exclude refinement. Published results may differ in evaluation frames and ground-truth sampling, so this table is a reference rather than a strictly matched comparison.

Direct reconstruction: LiNeXt and RapidLiDAR. Both train standalone, non-generative networks that directly optimize the final scene geometry under ground-truth Chamfer supervision. They target only the endpoint, whereas LiTE must preserve both the final geometry and the intermediate evolution of a pretrained generative teacher. This different objective is consistent with their stronger reconstruction results, which we acknowledge.

Flow-based generation: LiFlow. LiFlow learns a new conditional flow-matching model rather than distilling an existing generator, with an explicit Chamfer matching term. Accordingly, it achieves lower CD† than LiTE (0.228 vs. 0.283), while LiTE achieves lower BEV-JSD† (0.361 vs. 0.367) and higher IoU† at 0.2 / 0.1 m (25.81 / 13.67 vs. 25.1 / 12.9).

Trajectory distillation: LiTE. LiTE reuses the pretrained LiDiff prior. Its student performs teacher-aligned latent micro-steps within each transition, and VCLT refreshes scan correspondences and ray visibility as the queries move. This approximates the teacher's intermediate evolution while evaluating the full sparse U-Net only once per transition. Among LiDiff-based distillation methods, LiTE achieves the best CD and BEV-JSD with 4 full-backbone evaluations instead of 16.

Extension to a flow-based teacher. We also adapted LiTE to the official LiFlow model as the teacher, building trajectories from its Euler integration.

Table R3. LiTE distilled from the LiFlow teacher (latency on one NVIDIA H800).

MethodFull-backbone evalsCD† ↓BEV-JSD† ↓IoU† 0.5 / 0.2 / 0.1Generation latency (s) ↓
LiFlow (teacher)180.2280.36737.2 / 25.1 / 12.92.83
LiTE (LiFlow teacher)40.2130.35938.13 / 26.01 / 13.630.97

The four-step student improves on its teacher in all refined metrics while reducing latency by 2.9×, showing that the framework also applies to flow-matching teachers.

PatchScene (patch-based voxel diffusion, about 900k output points per frame versus our 180k) is discussed separately rather than as a matched comparison.

Overall, we distinguish direct endpoint reconstruction, flow-based generative modeling, and teacher-based trajectory distillation, and no longer claim overall state-of-the-art accuracy. LiTE achieves the best CD and BEV-JSD among LiDiff-based distillation methods with far fewer full-backbone evaluations.

AuthorsOpenReview ↗

General Comment, Part 3 of 3 (to all reviewers)

3. Isolation ablations

We agree that the original ablations changed several factors at once. Table R4 reports single-factor controls, now added to the revised paper (SemanticKITTI seq. 08, four steps, † = refined; all variants have 33.70 M parameters except C4 with 33.59 M and D6 with 33.40 M). Rows are grouped by the question they answer:

  • A: full model and two extra seeds, giving the noise level.
  • B: parameterization × EMA agreement, separating the factors mixed in the original Table 2 (jDyk W2, Xdt9 W2).
  • C: intermediate supervision and recurrent depth (jDyk Q1, Xdt9 Q3, KDhK Q4).
  • D: VCLT components, removed one at a time (jDyk Q1, KDhK W2 / Q1).
  • E: supervision terms and a minimal configuration (Xdt9 W2 / Q3).

Table R4. Single-factor ablations.

IDVariantCDCD†JSD†IoU† 0.5 / 0.2 / 0.1
A0Full LiTE0.3590.2830.36136.82 / 25.81 / 13.67
A0, two other seeds0.361 / 0.3570.281 / 0.2790.359 / 0.36337.13 / 26.03 / 14.02; 36.52 / 27.65 / 14.31
B1Direct, w/o EMA agreement (original Table 2)0.4340.3850.36628.08 / 16.21 / 8.31
B2Direct, w/ EMA agreement0.4210.3620.36829.83 / 17.13 / 9.12
B3CTM, w/o EMA agreement0.3740.2960.36336.72 / 25.93 / 13.62
C1w/o intermediate teacher-state supervision0.5180.4730.39624.73 / 12.35 / 6.74
C3One latent update per transition0.4530.4170.38427.37 / 13.92 / 7.34
C4w/o VCLT: Radius Attention0.3740.2950.36335.60 / 22.89 / 10.81
D1w/o visibility routing0.3690.2910.36436.74 / 25.63 / 12.46
D2Frozen candidates0.3700.2870.36736.53 / 25.74 / 13.02
D3w/o global motion g0.3680.2930.37136.71 / 25.77 / 12.63
D4GRU → parameter-matched MLP0.4120.3640.38132.69 / 23.23 / 11.09
D5w/o free-space loss0.3600.3060.37934.67 / 25.56 / 12.69
D6w/o VCLT: Closest Point0.3760.3110.36334.43 / 22.17 / 11.28
E2w/o L_teacher0.4860.4520.38827.24 / 13.57 / 6.98
E6w/o structural losses0.3670.2920.36335.34 / 24.02 / 12.51
E7Minimal (L_agreement + L_teacher + L_position)0.3970.3430.37632.36 / 26.28 / 12.17

Main conclusions:

  • Teacher-aligned intermediate supervision is the main source of the gain. With the same architecture, parameters, and compute, removing it raises CD† from 0.283 to 0.473 (C1), and a single internal update also hurts (C3, 0.417). The gain does not come from extra depth or capacity. (jDyk W2 / Q1, Xdt9 W2 / Q3, KDhK Q4)
  • The parameterization drives the original Table 2 gap (B3 vs. B1: 0.296 vs. 0.385); EMA agreement adds a smaller gain. (jDyk W2, Xdt9 W2)
  • Visibility routing contributes on its own, but less (D1: 0.291, outside the seed range 0.279–0.283). (jDyk Q1, KDhK W2 / Q1)
  • Every VCLT component matters, most of all GRU history (D4) and free-space supervision (D5). (KDhK W2 / Q1)
  • Simpler supervision is not sufficient: structural losses are optional (E6), but removing L_teacher (E2) or the minimal configuration (E7) is clearly worse. (Xdt9 W2 / Q3)
AuthorsOpenReview ↗

Summary Comment (to all reviewers)

Dear All,

We sincerely thank all reviewers for their thoughtful feedback. Within the limited rebuttal period, we have made our best effort to address every concern with new experiments, corrected measurements, and detailed clarifications, and we have revised the paper accordingly.

Our main efforts are summarized as follows:

  • Corrected the speedup with a consistent latency breakdown (jDyk Q2, Xdt9 W1/Q1, KDhK W3/Q5\color{blue}{\text{jDyk Q2, Xdt9 W1/Q1, KDhK W3/Q5}}). We acknowledged and corrected an inconsistent timing comparison in the original submission (General Comment, Part 1).
    • Consistent accounting (Xdt9 W1/Q1, KDhK W3\color{blue}{\text{Xdt9 W1/Q1, KDhK W3}}): with identical preprocessing on all methods, LiTE is 2.8× faster than ScoreLiDAR in denoising and 1.4× faster end-to-end, with 4 instead of 16 full-backbone evaluations.
    • Component-level breakdown and protocol (Xdt9 Q1, KDhK Q5\color{blue}{\text{Xdt9 Q1, KDhK Q5}}): we reported pre/post-processing, denoising, and total time for LiDiff, LiDPM, ScoreLiDAR, Distillation-DPO, and LiTE on one GPU with batch size 1, and specified synchronization, warm-up, data transfer, and refinement.
    • Matched depths (Xdt9 W1/Q1\color{blue}{\text{Xdt9 W1/Q1}}): the denoising speedup over ScoreLiDAR grows with the number of steps, from 1.3× to 1.7×, while one-step LiTE already reaches a lower CD† than eight-step ScoreLiDAR.
  • Clarified our positioning and added recent baselines (jDyk W1/Q2/Q3, KDhK W1/Q3\color{blue}{\text{jDyk W1/Q2/Q3, KDhK W1/Q3}}). We withdrew the unqualified state-of-the-art claim and positioned LiTE as a teacher-based trajectory distillation framework (General Comment, Part 2).
    • Distillation-DPO (jDyk W1/Q2\color{blue}{\text{jDyk W1/Q2}}): LiTE outperforms it on CD, BEV-JSD, and IoU with 4 instead of 16 full-backbone evaluations, and we listed the CFG settings and conditioning reuse of all distillation baselines.
    • LiNeXt and RapidLiDAR (jDyk Q3, KDhK W1/Q3\color{blue}{\text{jDyk Q3, KDhK W1/Q3}}): we evaluated both under a common protocol and acknowledged their stronger endpoint reconstruction, while clarifying that they are direct reconstruction networks rather than generative distillation methods.
    • LiFlow as a stronger teacher (jDyk Q3, KDhK Q3\color{blue}{\text{jDyk Q3, KDhK Q3}}): we distilled the official LiFlow model with LiTE; the four-step student surpasses its LiFlow teacher on all refined metrics (CD† 0.213 vs. 0.228) with 2.9× lower latency.
  • Isolated the core mechanisms with single-factor ablations (jDyk W2/Q1, Xdt9 W2/Q3, KDhK W2/Q1/Q4\color{blue}{\text{jDyk W2/Q1, Xdt9 W2/Q3, KDhK W2/Q1/Q4}}). We added 15 controlled variants and two extra seeds (General Comment, Part 3).
    • Teacher-aligned supervision (jDyk Q1, KDhK Q4\color{blue}{\text{jDyk Q1, KDhK Q4}}): with identical architecture, parameters, and compute, removing intermediate teacher-state supervision raises CD† from 0.283 to 0.473, so the gain does not come from extra recurrent depth or capacity.
    • Table 2 confound and VCLT components (jDyk W2, KDhK W2/Q1\color{blue}{\text{jDyk W2, KDhK W2/Q1}}): the parameterization drives the original Table 2 gap, and every VCLT component, including visibility routing, contributes beyond seed variance.
    • Supervision terms (Xdt9 W2/Q3\color{blue}{\text{Xdt9 W2/Q3}}): the structural losses are optional, but the minimal supervision configuration is clearly worse.
  • Clarified training details, deployment, and presentation (Xdt9 W3/Q2, KDhK W3/Q2\color{blue}{\text{Xdt9 W3/Q2, KDhK W3/Q2}}).
    • Training and data (Xdt9 Q2, KDhK W3\color{blue}{\text{Xdt9 Q2, KDhK W3}}): the student is randomly initialized and uses the teacher only offline; 5.2% now refers explicitly to the distillation stage, and we reported its cost separately.
    • Latent queries (KDhK Q2\color{blue}{\text{KDhK Q2}}): we explained that queries act only as lookup points at inference, so moving away from their lattice cells causes no mismatch.
    • Presentation (Xdt9 W3\color{blue}{\text{Xdt9 W3}}): we clarified the roles of internal queries, supervision-only intermediate clouds, and decoder outputs, and replaced the schematic scenes in Figures 2 and 3 with real SemanticKITTI point clouds.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.