- Rating
- 2
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 3
- Soundness
- 2
Read review
Paper summary
ELiCv2 extends ELiC for LiDAR geometry compression on embedded hardware. It combines selection of precomputed CDF tables, hierarchical sparse-convolution kernel-map construction, and temporal conditioning using an ego-motion-aligned reference frame. Experiments on four datasets report improved compression–latency trade-offs.
Critical strengths
The reported deployment gains are useful. On Jetson Thor, inter encodes and decodes 16-bit nuScenes frames in 34.8 and 40.3 ms, respectively, substantially faster than ELiCv1. Temporal conditioning also improves compression over the corresponding intra models across all four datasets.
Critical weaknesses
The methodological advance over related work is insufficiently established. The entropy interface shares the central design of Learning Switchable Priors, §§III-A–B: jointly learning a finite distribution set and an index predictor, then selecting precomputed CDF tables for entropy coding. That work also includes two-dimensional distribution indexing. ELiCv2 differs in its categorical codebook with row/column parameters and low-rank interactions, and its row/column selector trained with Gumbel–Softmax. However, comparison against per-voxel CDF construction in Table 4 does not establish the benefit of these specific choices over existing learned-table designs.
ELiCv2's kernel-map construction is closely related to the neighborhood lookup procedure in Zhou et al. (2011), §III-C: both use lookup tables to identify the relevant parent neighbor and child octant, deriving child-level neighborhoods from parent-level neighborhoods. ELiCv2 applies this mechanism to sparse-convolution kernel maps. The paper should distinguish this application from the established neighborhood propagation algorithm when stating its contribution.
The overall speedup needs a matched runtime breakdown and end-to-end ablations. At 16 bits, Table 3 shows a mean encoding-time reduction of 84.90 ms from ELiCv1 to ELiCv2 intra. Tables 4 and 5 report mean savings of 44.23 ms for the entropy interface (arithmetic coding to indexed rANS) and 3.28 ms for kernel-map construction, respectively. These component savings are substantially smaller than the overall reduction. A breakdown on identical test frames and controlled end-to-end ablations are needed to establish where the additional acceleration comes from.
For Ford, the paper uses KISS-ICP to estimate inter-frame transforms but does not state whether this computation is included in encoding latency.
Questions for authors
- What substantive advance do the learned categorical codebook and its row/column selector provide beyond established CDF-table selection?
- Consider providing a breakdown of encoding and decoding times for ELiCv1 and ELiCv2 intra. An end-to-end comparison of the proposed and hash-based kernel-map builders, with all other components fixed, would help isolate this optimization's contribution. Please also clarify whether the reported encoding time on Ford includes KISS-ICP pose estimation.
8 comments
W2 + Q2(b) — the distinction from Zhou et al. §III-C, and the two kernel-map builders compared
W2. We agree with the reviewer and will cite Zhou et al. (2011), Section III-C. The parent-neighbor and child-octant lookup relation is established prior work, and our construction uses that geometric relation. We do not claim the neighborhood recurrence or its LUT realization as novel. The contribution we claim is its occupancy-driven realization as a sparse-convolution kernel-map update within progressive entropy decoding.
The distinction we would draw is the availability of the hierarchy. Zhou et al. construct octree neighborhoods on the GPU from an input point set, so the whole tree is in hand and the neighborhood relations at every level can be materialized before the surface reconstruction that consumes them begins. Our decoder has no such input: the finer-level topology exists only in the bitstream and is revealed one level at a time by entropy decoding, so the kernel map for level ℓ+1 cannot be built until the occupancy symbols at level ℓ have been decoded. Topology recovery, kernel-map propagation and entropy decoding are causally interleaved:
K(ℓ) -> neural CDF-index prediction -> entropy-decode occupancy(ℓ)
-> child support and K(ℓ+1) -> next prediction
This is a difference of setting, not of capability — the coupling between progressive entropy decoding and kernel-map state does not arise when the hierarchy is given up front, so there was no reason for prior work to build for it. Equally, it is not optional for us, and we are not claiming that neighborhood propagation in general requires a completed octree. Our construction instantiates the recurrence in the codec's active-feature index space: a prefix sum of child counts and the child's occupied-octant rank assign each active child a contiguous index, a parent-map lookup and an occupancy test identify each target child, and the same indexing rule gives its feature-row address, populating the next kernel map in the convolution's offset order with -1 for absent neighbors. Appendix D specifies the indexing and derives equivalence to coordinate-based construction.
Q2(b). We have now run the controlled end-to-end comparison. We substituted torchsparse's coordinate-hashing builder (build_kernel_map, mode='hashmap') for our propagation at every level, on both the encode and the decode side, with nothing else changed. 30 test frames per dataset, posQ = 4, min-of-3, on an A100 — a host GPU, not the Jetson of Table 5, so these absolute times must not be substituted into the Jetson table of Table 3. The swap is exactly controlled and we can show it rather than assert it: the two builders produce identical kernel maps, so the bitstreams are byte-identical in 120 of 120 frames and the decoded voxel sets agree in 120 of 120. The rate is unchanged by construction, so the differences below are the end-to-end effect of swapping the builder.
| Dataset | Voxels | Encode: ours → hashing | Δ | Decode: ours → hashing | Δ |
|---|---|---|---|---|---|
| nuScenes | 29,564 | 18.44 → 20.17 | +1.73 | 23.72 → 25.53 | +1.81 |
| SemanticKITTI | 125,522 | 36.82 → 38.99 | +2.18 | 45.68 → 47.85 | +2.16 |
| Ford | 77,858 | 31.72 → 33.62 | +1.90 | 38.86 → 41.09 | +2.23 |
| V2X-Seq | 56,424 | 28.61 → 30.76 | +2.15 | 35.81 → 38.16 | +2.34 |
| Mean | +1.99 | +2.13 |
We also ran the same swap on Jetson Thor, the platform Table 5 was taken on, with the same controls — the seed map at octree level ℓ=2 is identical in both variants, so only child-level derivation differs, and the bitstreams are byte-identical in 120 of 120 frames there as well. Encode, ms/frame:
| Dataset | ours → hashing | Δ |
|---|---|---|
| nuScenes | 43.06 → 45.48 | +2.42 |
| SemanticKITTI | 113.04 → 117.30 | +4.26 |
| Ford | 85.59 → 89.44 | +3.85 |
| V2X-Seq | 76.64 → 80.06 | +3.42 |
| Mean | +3.49 |
The mechanism returns 1.75× more time on the embedded device than on the host — 3.49 ms against 1.99 ms — on a frame that is itself 2.75× more expensive. Against a fixed real-time budget that is the direction that matters: the absolute saving grows precisely on the device that sits near the deadline, where the A100 has ample headroom. As a fraction of frame time the term is smaller on Thor (4.4% against 6.9%), because the whole frame grows faster than this one stage does. The swap is also not an explanation for the 37.4 ms residual in the published-table arithmetic, which is an order of magnitude larger than anything it moves. And it holds the convolution backend fixed: it measures how the map is derived, not how it is consumed.
W3 + Q2(a) — where the speedup comes from
The subtraction is correct, we reproduced it, and part of the answer is in that figure. From our logs at bit depth 16: ELiCv1 149.25 ms, ELiCv2 C=32 intra 64.36 ms, a difference of 84.89 ms — the reviewer's 84.90 ms up to rounding — against 44.23 ms in the submitted Table 4 and 3.28 ms in Table 5, leaving 37.4 ms unaccounted.
Why the three tables cannot sum. Table 5 times only bit depths 3 to leaf−1, excludes bit depth 2 from both columns, and runs the hashing baseline with its ImplicitGEMM bitmask and backward-map bookkeeping disabled — a deliberate lower bound, not an estimate. Table 4 is an ablation within ELiCv2. Neither was designed as a decomposition of the ELiCv1 → ELiCv2 difference.
The two published rows also did not share a measurement boundary, and we have now re-measured on one — encode and decode totals for both codecs, with the stage split reported for encoding. For fairness we aligned the voxelization of ELiCv1 and ELiCv2: it is performed once per frame, outside the timed region, and the identical voxel set is passed to both, so it is neither a confound in the input nor a term in either timer. Both codecs run in one process on Thor, on the same 30 frames per dataset, at the clock Table 3 uses. The timer covers every codec stage after that shared voxelized input — each codec's entropy coder runs inside it, and both emit real bitstreams whose sizes we record as the check that they do. Four-dataset means, bit depth 16, ms:
| pyramid / expand Δ | backbone + kernel-map Δ | entropy Δ | total Δ | speedup | |
|---|---|---|---|---|---|
| encode | 4.40 | 25.20 | 49.33 (62.5%) | 78.92 | 2.07–2.44× |
The entropy interface is the largest term across the four datasets — 62.5% of the encode gap, from 47.3% on nuScenes to 70.1% on SemanticKITTI. ELiCv1 spends 23.2–78.7 ms per frame on the entropy stage against our 7.6–12.5 ms when encoding (3.0–6.3×). Decode totals are in Table 3. We do not split them, because the per-stage instrumentation perturbs the decoder by 8.5–16.2% of its own runtime.
Under this boundary the mean encode gap is 78.92 ms against the 84.90 ms the published rows imply. The two figures are not interchangeable — they differ in measured span and frame sample — and we do not apportion the difference, because this profile does not separate those causes. Table 3's bit-depth-16 rows are now reported on the boundary measured here, where the end-to-end encode difference is 79.9 ms. The Δ columns above come from the instrumented run and sum to 1.0 ms less.
The controlled entropy-interface ablation, also on Thor. The submitted Table 4 figures came from an earlier measurement setup, so the times below are not comparable to them. We replace them for attribution with a three-way experiment run under one setup. All three share one cached backbone pass, so only the entropy interface differs: (A) per-voxel continuous PMF with an arithmetic coder, (B) the identical preparation with rANS, isolating the coder, (C) ours, a predicted table index against a static integer CDF bank. Means over four datasets, ms:
| Variant | prep | coding | total |
|---|---|---|---|
| A continuous PMF + arithmetic | 57.99 | 14.19 | 72.18 |
| B continuous PMF + rANS | 57.29 | 6.38 | 63.67 |
| C table index + indexed rANS (ours) | 2.21 | 8.10 | 10.31 |
The coder alone buys 1.13×, the interface alone 6.18×, both together 7.00×. The reason is the prep column: A → B leaves it untouched (57.99 → 57.29, as it must — the same per-voxel CDFs are built either way) while A → C collapses it to 2.21 ms. A and B differ by 6--7 bytes of output, confirming they code the same distribution with different coders. C's is 1.04% larger, the rate cost of the quantized bank, which the paper reports. No separate continuous head was needed: the model's own mixer composes a per-voxel PMF from the selector logits and the learned PMF tables, and A/B use that composition with deterministic softmax weights instead of top-1 selection.
What these establish. They localize where the time goes under one stated boundary. Isolating what each mechanism is worth is a separate experiment, and the three-way ablation above is that experiment. The kernel-map mechanism sits inside the backbone term and the builder swap we report under Q2(b) bounds it at 3.49 ms here, so that term is not mostly the kernel map. Neural prediction is excluded from all three ablation variants alike, so those are entropy-stage figures.
W1 + Q1 — the distinction from Learning Switchable Priors, and the measured selector ablation
The review states four weaknesses and two questions, and the second question bundles three requests. We number the weaknesses W1–W4 in the order given and answer them across four separately posted comments: this one covers W1 + Q1 (advance over established table selection), a second covers W2 + Q2(b) (Zhou et al., and the end-to-end comparison of the two kernel-map builders), a third W3 + Q2(a) (matched runtime breakdown), and a fourth W4 + Q2(c) (whether Ford's encoding time includes KISS-ICP), closing with a summary.
W1. We thank the reviewer for identifying Learning Switchable Priors as the closest prior work to our entropy interface. The revision cites and discusses it. The reviewer's characterization is accurate, including two-dimensional indexing. We claim neither joint learning of a finite distribution set nor factorized indexing as novel. Our contribution concerns the categorical occupancy model stored in the tables and the context-to-table decision used to select it. The comparison below concerns its selector in Sections III-A and III-B.
Switchable predicts index coordinates, not per-symbol density parameters, so the distinction is not whether tables are learned, but how the distributions and selection scores are parameterized.
Each coding stage represents four octants by one of 16 occupancy symbols — bit patterns, not ordered magnitudes, whose numerical order defines no natural Gaussian location-scale model. Our entries learn probabilities over occupancy patterns without a prescribed Gaussian, GGM or GMM form — "categorical" does not mean parameter-free. A rounded-coordinate selector could address a categorical codebook: argmax is our design choice, not a necessity of the alphabet. The selector emits two
T-way vectors and formsk = T*i + jfrom their argmax indices, so atT = 32, 64 logits address 1,024 tables rather than a flat 1,024-way output. Bank and selector are both learned with the backbone, training uses Gumbel-Softmax and inference uses hard selection.Stable selection, not just speed. With a shared integer-CDF bank a single table mismatch desynchronizes the remaining bitstream, so what matters is what each selector's native output must preserve. A rounded coordinate must stay nearer its own bin than any boundary. Our score vectors need only keep the winner on each axis — neither exact logit values nor the full ranking — so a common shift or positive scaling within a head leaves argmax unchanged, and an encoder-side top-two margin greater than
2*epsilonpreserves the winner when each decoder logit differs by at mostepsilon. Our argument concerns these different output representations and invariances, not a guarantee that argmax is universally more robust or that the codec is platform-independent.Q1, the measured ablation. It is an ablation of a Switchable-inspired coordinate selector under our categorical-codebook training objective, not a reproduction of Learning Switchable Priors. Three deviations matter and we report all three: we use squared rather than absolute distance to the integer positions, the candidate weights multiply our categorical log-PMFs rather than weighting per-candidate rates as in that paper's Eqs. 2–3, and the per-axis sharpness is a learnable parameter rather than their annealed temperature treatment. Everything else is held fixed — codebook, backbone, data and schedule. nuScenes, C=32 intra, three seeds, each trained to 199,500 steps. Eight identical test frames, means over the three seeds:
Its gap is +28.8 to +40.3 across seeds and does not close with training: +18.8 at 12k steps, +34.7 at convergence. On our codebook and objective the training surrogate does not predict the deployed operation for a coordinate selector, and does for ours.