{"id":"0d46affe-0408-44a0-aea9-3e5e3bbe26c5","arxiv_id":"1908.08996","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":5.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":3,"one_line_summary":"A lookup table that stores precomputed outputs of the per-point MLP can replace network inference in point-wise point cloud models, achieving near-identical accuracy with much lower CPU latency.","lead":"The authors replace the per-point neural network computations in a PointNet-style 3D point cloud classifier with a precomputed lookup table, turning inference into simple memory reads. This makes a simple point-wise classifier run about 11 times faster on a CPU, at nearly the same accuracy, and they argue the trick works because each point is processed by functions of just three coordinates.","discovery_kind":"new_application","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The claim of 'no performance degradation' is not supported by the advertised 15MB configuration; it requires the 8GB S=200 table, and the 32x speedup partly reflects removing T-Nets rather than the lookup table alone.","rationale":"The reader's stated weakest assumption is the expressiveness of the pointwise architecture, but their rationale also flags the 15MB/8GB inconsistency and the conflation of architecture simplification with lookup speedup. My concern aligns with that rationale rather than with the stated weakest assumption, so I mark partial agreement. I do not see a fatal flaw in the core lookup-table idea: for a fixed pointwise network, sampling h_s on a grid, storing quantized values, and fine-tuning the head is mechanically sound and is supported by the main experiments. The load-bearing problem is that the headline claim packages speed, memory, and accuracy in a way that the paper's own tables contradict. Conditional acceptance is therefore appropriate, but the paper should be revised so the reported configuration matches the claimed performance. My concrete test would settle whether the contradiction is merely a presentation issue or a deeper reproducibility problem.","tokens_in":8651,"tokens_out":9687,"duration_ms":104035,"concrete_test":"Reproduce Table 4 with the authors' training and fine-tuning protocol, measuring ModelNet40 overall accuracy and CPU latency for S=25 (15MB) and S=200 (8GB), along with the PointWise-no-table baseline. If S=25 yields about 88.86% (0.34 points below PointNet) and S=200 yields about 89.51%, then the abstract must be revised to state the memory/accuracy trade-off explicitly rather than claiming no degradation with a 15MB table.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim in the abstract and Section 5.3 is that lookup-table inference runs in 1.5ms on an i7-8700 with 32x speedup over PointNet 'without any performance degradation.' This is not supported by the same configuration that the paper highlights: Table 4 shows that the 15MB table (S=25) yields 88.86% overall accuracy on ModelNet40 versus PointNet's 89.2%, a 0.34-point drop that Section 5.5 itself describes as 'merely drops 0.4%.' The no-degradation result is only achieved with S=200, which requires 8GB of memory. Thus the abstract's conjunction of 1.5ms, 15MB, and no degradation is internally inconsistent. Additionally, the speedup comparison is measured against PointNet with its two T-Net modules, but the lookup method removes those modules; the paper's own PointWise baseline without lookup already runs in 17ms (Table 1), so roughly 3x of the 32x speedup comes from architectural simplification rather than from the lookup table. Section 4's geometric argument about isosurface tangency is informal and does not address this quantitative discrepancy. The lookup-table method itself appears sound and reproducible in principle, but the headline claim as written overstates what the reported experiments establish.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes JustLookup, a method to accelerate inference for point-wise deep networks on point clouds. The key observation is that PointNet-style architectures compute per-point features via a shared MLP which, for each output channel, is a function of the three input coordinates. The authors discretize the input volume into S^3 voxels and precompute the MLP outputs on the voxel grid, storing them in a lookup table indexed by quantized coordinates. During inference, per-point features are read from memory, max-pooled, and passed to a task head (classification or retrieval). To recover accuracy lost to approximation, the head is fine-tuned on the approximated features. Experiments on ModelNet10/40 and ShapeNet-Core55 report CPU inference at 1.5 ms for 1024 points, a 32x speedup over PointNet, with accuracy claims that vary between 'no performance degradation' and 'almost the same performance' across different configurations. The paper also offers a geometric interpretation of max pooling as level-set tangency to explain why point-wise networks can capture local structure.","tokens_in":8913,"tokens_out":5553,"duration_ms":52442,"significance":"The central idea—exploiting the three-dimensional input of point-wise networks to turn feature extraction into memory lookups—is genuinely original and potentially useful for CPU-bound or edge deployments of simple point cloud models. The paper provides a concrete memory/accuracy analysis (Eq. (5)-(6), Table 4) and the construction is straightforward to reproduce in principle. If the claims were stated accurately, the method would be a valuable engineering contribution. However, the significance is narrower than the headline suggests: the method applies only to point-wise architectures without transform networks, and the reported speedup and 'no degradation' claim conflate the lookup table's effect with architectural simplification. The geometric interpretation in Section 4 is informal and does not provide quantitative support, so the paper's primary value rests on the empirical speedup and accuracy trade-off.","major_comments":[{"comment":"The abstract's phrase 'without any performance degradation' is not supported by the configuration that the paper advertises with small memory. Table 4 shows that the 15 MB table (S=25) yields 88.86% overall accuracy on ModelNet40, which is 0.34 points below PointNet's 89.2%, and Section 5.5 itself calls this 'merely drops 0.4%.' The no-degradation result relative to PointNet is only achieved at S=200, which requires 8000 MB. Please report the resolution/memory trade-off explicitly and revise the abstract and introduction so that the 'no degradation' claim is associated with the 8 GB configuration, not with the 15 MB configuration.","section":"Abstract, Introduction, Section 5.5, Table 4"},{"comment":"The claimed 32x speedup over PointNet is not an apples-to-apples comparison of the lookup-table method. PointNet's 49.15 ms CPU inference includes two T-Net modules, which the paper removes in its PointWise baseline; the lookup table is then applied to the resulting point-wise network. The paper's own PointWise baseline without any lookup table already runs in 17 ms (Table 1), so the speedup attributable to the lookup table is roughly 17/1.5 ≈ 11x, not 32x. The remaining factor of about 3 comes from removing the T-Nets, which are not part of the point-wise functions and are not accelerated by the proposed method. Please either benchmark against PointWise as the baseline or decompose the speedup into the contributions from architectural simplification and from lookup-table access.","section":"Table 1, Section 5.3"},{"comment":"The accuracy comparisons are made against PointNet, but the point-wise architecture without T-Nets is itself a weaker baseline: PointWise achieves 87.95% on ModelNet40 versus PointNet's 89.2%, a 1.3-point gap. The later claim that the fine-tuned sampled model at S=200 reaches 89.51% and 'maintains the same performance' as PointNet is relative to a different architecture. Reporting the accuracy delta relative to PointWise and to PointNet separately would make clear what the lookup-table approximation itself costs and what the architectural simplification costs.","section":"Section 5.3, Section 5.5"}],"minor_comments":[{"comment":"The title says 'One Millisecond' but the reported inference time is 1.5 ms; please adjust the title or the reported time for consistency.","section":"Title"},{"comment":"The quantization scheme uses per-channel MIN and MAX values over the volume, but the paper never states how these extrema are estimated (e.g., over a dense random grid or analytically). Please specify the procedure and whether the MIN/MAX values are recomputed after fine-tuning.","section":"Section 3, Eq. (5)"},{"comment":"Please clarify whether fine-tuning of the model M is performed by backpropagating through the lookup table (which would require differentiable rounding) or by using the original MLP with the approximate outputs; the current description is ambiguous.","section":"Section 5.1"},{"comment":"The retrieval results report 'Ours' and 'Ours (Sampled PointWisef)' without specifying the voxel resolution S used for those experiments. Since accuracy depends on S, please state the configuration (and memory size) for each retrieval result.","section":"Tables 2 and 3"},{"comment":"The statement that 'we can achieve the same accuracy as PointNet by only using 500 points' is missing the voxel resolution S used for that experiment; please add this detail to make the claim reproducible.","section":"Section 5.6"},{"comment":"The geometric interpretation with level sets is presented as an explanation of why point-wise architectures work, but it is not formalized. I recommend clearly labeling it as intuition and, if possible, adding real examples of learned level sets instead of an idealized schematic.","section":"Section 4 and Figure 2"},{"comment":"The accuracy axis of Figure 3(a) starts at 82%, which visually exaggerates the differences among configurations. Please use a scale that does not distort the reported trade-offs.","section":"Section 5.5, Figure 3(a)"}],"recommendation":"major_revision","confidential_remarks":"The core lookup-table idea is sound and could be a solid contribution after the claims are corrected. The main revision needed is to make the speedup and accuracy statements consistent with the reported tables: the no-degradation claim requires the 8 GB table, and the 32x speedup includes removing T-Nets. I am not concerned about novelty or scope, but the current abstract and introduction overstate what the experiments establish. The geometric-interpretation section is the weakest part of the paper and should be de-emphasized or rewritten as intuition, because it does not substantively support the empirical claims."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Quick take on 1908.08996. The core trick is real: point-wise networks like PointNet's shared MLP are just a set of 3-variable functions, so you can tabulate them with a quantized lookup table and fine-tune the downstream head. That is a legitimate and useful observation, and I don't know of a prior paper that does exactly this. The CPU speedup is real too: 1.5 ms inference on an i7-8700 against a 17 ms point-wise baseline is a solid ~11x, and the reported accuracy after fine-tuning largely holds up. The authors are also honest in the limitation section about the point-wise restriction.\n\nThe soft spots are real but mostly in the reporting, not the method. The abstract's conjunction of '1.5 ms, 15 MB, and no performance degradation' doesn't match the body. Table 4 shows the 15 MB table (S=25) gives 88.86% on ModelNet40, 0.34 points below PointNet's 89.2% and actually above their own PointWise baseline (87.95%). The no-degradation claim only holds for S=200, which needs 8 GB. So the headline overstates what's in the experiments. Second, the 32x speedup over PointNet conflates removing the two T-Net modules with the lookup table gain; their own PointWise baseline already runs in 17 ms, so the table alone is ~11x, not 32x. Those are fixable with clearer ablations. The geometric tangency argument in Section 4 is informal, but it's not load-bearing; the quantitative evidence stands on its own.\n\nThe deeper limitation is the expressiveness of point-wise architectures. The stripped-down PointWise baseline is 1.3 points below PointNet on ModelNet40, and the method only applies to this architecture class. That's not a fatal flaw, it's a scope condition, and the paper states it.\n\nWho is this for? People working on CPU inference for point cloud models, or on table-based approximations of small continuous networks. It deserves a serious referee; I'd recommend conditional acceptance with the requested clarifications, and a demand that the abstract match the strongest config actually reported.","headline":"Neat and valid acceleration trick for point-wise point cloud networks, but the abstract's trio of 1.5 ms, 15 MB, and no degradation does not hold at 15 MB; no-degradation needs the 8 GB table.","tokens_in":9463,"tokens_out":2530,"would_cite":false,"duration_ms":22024,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"A lookup table can replace the point cloud network at inference: 1.5 ms on CPU.","keywords":["point cloud","lookup table","3D object classification","3D object retrieval","point-wise network","model acceleration","max pooling","voxel sampling"],"falsifier":"Train PointWise on a fine-grained part-segmentation dataset and compare per-part IoU with PointNet; if the point-wise model underperforms by a large margin, the lookup table claim 'no performance degradation' fails at the architecture level, not the table level.","tokens_in":8424,"feed_emoji":"⚡","tokens_out":6266,"duration_ms":61253,"temperature":0.7,"pith_summary":"PointNet-style networks extract a global point-cloud feature by max-pooling the outputs of a shared multilayer perceptron applied to each point's $(x,y,z)$ coordinates alone. The paper argues that because every point-wise function is just a map from $\\mathbb{R}^3$ to $\\mathbb{R}$, the whole feature extractor can be sampled on a voxel grid and stored in a lookup table, turning inference into an array index and a max operation. On ModelNet40 classification the tabled model runs in 1.5 ms on a single Intel i7-8700 CPU core, a 32x speedup over PointNet, while after fine-tuning the classification head it retains or slightly improves accuracy. The method also works on ShapeNet object retrieval, and the authors give a geometric story in which max pooling makes the level sets of the learned functions tangent to the object surface, which is how local structure is captured without explicit neighborhoods. The approach is limited to point-wise architectures, since global transformation networks (T-Nets) break the per-point decomposition.","feed_headline":"Point cloud inference drops to 1.5 ms on CPU","feed_subtitle":"Precomputed 3D lookup tables deliver a 32x speedup over PointNet with no accuracy loss.","key_machinery":"The key machinery is the factorization $F(X) = \\max_{p} (h_1(x_p), \\dots, h_m(x_p))$, where each $h_s: \\mathbb{R}^3 \\to \\mathbb{R}$ is a 3-variable function implemented by the shared MLP. Because the input space is only 3-dimensional, the set $\\{h_s\\}$ can be sampled at voxel centers and stored as a 4-dimensional table indexed by voxel position and function index; quantization to 8-bit values shrinks the table without hurting accuracy. At test time each point produces its $m$ function values by memory lookups, and a max over points yields the global feature, followed by a small trained head. The table acts as a universal precomputation of the entire feature extractor, so network depth and width no longer affect inference cost.","core_discovery":"The central discovery is that the deep 3-variable functions $h_s(x)$ induced by a point-wise network can be offline-encoded into a lookup table $T[i][j][k][s]$ with negligible loss in task accuracy. The paper constructs the table by subdividing $[-1,1]^3$ into $S^3$ voxels, evaluating each point-wise function at the voxel corner, quantizing the stored value to 8 bits, and then fine-tuning the network head so it is calibrated to the approximate features. At the default $S=200$ this delivers a 1.5 ms forward pass on CPU, and even at $S=25$ with 15 MB of memory the fine-tuned model reaches 88.86% overall accuracy on ModelNet40, only 0.4% below PointNet's published number. The paper further claims that the point-wise architecture implicitly captures local shape because max pooling grows each function's isosurface until it is tangent to the object at a critical point, so the absence of explicit neighborhoods is not a fatal limitation. The claim 'inference is only determined by memory access' holds regardless of how deep or wide the original network is.","pith_inferences":["The table can be viewed as a learned spatial basis; one likely extension is adaptive, density-aware voxelization, which would use more cells near object surfaces and fewer in empty space to cut memory further.","The paper's geometric tangency argument is informal; a formal bound relating the number of functions, voxel size, and surface-curvature would make the interpretation testable and could guide how many channels are needed for local detail.","Fine-tuning on table outputs may act as a regularizer, which could explain why Sampled PointWise_f sometimes beats PointWise; testing on small training sets would show whether the table softens overfitting.","The method could port to other coordinate-based networks, such as NeRF or occupancy fields, when the network is a sum or max of per-coordinate computations, though memory requirements would need rethinking."],"forward_implications":["Inference cost for point-wise networks becomes independent of network depth and width, so one could train very large models and compress them into the same table.","CPU-only and embedded devices can run point-cloud classification at real-time rates, since the 1.5 ms measurement is on a single CPU core without GPUs.","The fine-tuning step turns the table's quantization error into a training signal, which may mean lookup-table models can be treated as a form of learned robust features.","The same recipe applies to any task that max-pools functions of coordinates, such as implicit surface networks, as long as the per-point functions depend only on the point itself."],"supporting_citations":[{"why":"Supplies the point-wise architecture with max pooling whose per-point MLPs are the 3-variable functions to be tabulated.","marker":"[1]"},{"why":"Provides a hierarchical local-structure baseline for speed and accuracy comparison.","marker":"[2]"},{"why":"EdgeConv baseline used to demonstrate the speed advantage over graph-based point-cloud networks.","marker":"[3]"},{"why":"SO-Net baseline for retrieval and classification comparisons.","marker":"[4]"},{"why":"ModelNet dataset used to measure classification accuracy and the claimed speedup.","marker":"[14]"},{"why":"ShapeNet-Core55 / SHREC17 benchmark used for the retrieval evaluation.","marker":"[15]"}],"fun_headline_variants":["Point cloud speedup: 32x via lookup tables","1.5 ms point cloud inference on CPU","Lookup table replaces deep net for point clouds","Precomputed tables cut point cloud forward pass to 1.5 ms"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is that a point-wise network with no explicit neighborhood operations can be accurate enough on the task; if the underlying point-wise model is too weak, the lookup table simply encodes a weak function.","fun_headline_variants_meta":{"raw":{"variants":["Point cloud speedup: 32x via lookup tables","1.5 ms point cloud inference on CPU","Lookup table replaces deep net for point clouds","Precomputed tables cut point cloud forward pass to 1.5 ms"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000278,"raw_usage":{"total_tokens":1653,"prompt_tokens":942,"completion_tokens":711,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":558,"completion_tokens_details":{"reasoning_tokens":644}},"tokens_in":558,"tokens_out":711,"duration_ms":6593,"temperature":1.0,"reasoning_tokens":644,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-14T13:26:23.954731+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Train PointWise on a fine-grained part-segmentation dataset and compare per-part IoU with PointNet; if the point-wise model underperforms by a large margin, the lookup table claim 'no performance degradation' fails at the architecture level, not the table level.","supporting_citations":[{"cited_title":"Justlookup: One Millisecond Deep Feature Extraction for Point Clouds By Lookup Tables","cited_arxiv_id":"1908.08996","evidence_quote":"Supplies the point-wise architecture with max pooling whose per-point MLPs are the 3-variable functions to be tabulated."},{"cited_title":"Deep Learning on 3D Point Cloud PointNet [1] is the pioneer to apply deep neural networks to directly process unordered point clouds","cited_arxiv_id":null,"evidence_quote":"Provides a hierarchical local-structure baseline for speed and accuracy comparison."},{"cited_title":"𝒉𝟏𝟎𝟐𝟒 𝒙𝟐 …… …… …… 𝒉𝟏 𝒙𝒏 𝒉𝟐 𝒙𝒏","cited_arxiv_id":null,"evidence_quote":"EdgeConv baseline used to demonstrate the speed advantage over graph-based point-cloud networks."},{"cited_title":"However, it still gains impressive results on 3D vision tasks","cited_arxiv_id":null,"evidence_quote":"SO-Net baseline for retrieval and classification comparisons."},{"cited_title":"Exploiting the panorama representation for convolutional neural network classification and re- trieval,","cited_arxiv_id":null,"evidence_quote":"ShapeNet-Core55 / SHREC17 benchmark used for the retrieval evaluation."}],"review_version":1}