{"id":"d537f96e-2d00-4f6e-a644-62efbfc83646","arxiv_id":"2501.15722","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":3,"one_line_summary":"A framework that embeds implicit neural representations of 3D shapes, including feature-grid architectures, into a common space for accurate shape retrieval.","lead":"INRet is a method for measuring similarity between neural-network 3D shape representations (INRs) by converting their weights and feature grids into embeddings, then comparing those embeddings. It is the first retrieval approach that works for modern grid-based INRs and across different implicit functions, and it reports higher retrieval accuracy than converting shapes to point clouds or images.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Tab. 1 confounds retrieval method with input INR architecture: INRet is evaluated on higher-quality grid INRs while inr2vec is evaluated on lower-quality MLP-only INRs, so the reported 12.0% accuracy gain may reflect the underlying representation rather than the retrieval framework.","rationale":"The reader correctly identified the Tab. 1 confound and the strong dependence of cross-implicit-function accuracy on the explicit L2 loss. My stress test strengthens that concern by connecting it to the paper's own reconstruction-quality data (Tab. 15 and Tab. 16), which show retrieval accuracy tracks INR fidelity, making the MLP-only inr2vec baseline a weak point of comparison. I also add the architecture-sensitivity evidence from Tab. 14, which shows that the Conv3D encoder's effectiveness depends on preserving each grid architecture's native feature-combination convention, thereby qualifying the generality claim for arbitrary or future grid architectures. These are not internal inconsistencies — the paper is transparent about its design choices — but they mean the experimental record does not yet cleanly support the strongest accuracy claim. The cross-implicit-function results, where the only varying factor is the regularization, are internally sound and support the method's core usefulness. Therefore the verdict should remain CONDITIONAL: the method is plausible and promising, but the central accuracy comparison needs a matched-representation baseline and ideally code/error bars before the claims are taken as definitive.","tokens_in":23536,"tokens_out":1745,"duration_ms":17867,"concrete_test":"Retrain an inr2vec-style encoder on the same iNGP INR inputs that INRet consumes, using only the MLP head and ignoring the hash grid, and compare mAP@1 on the same query set. If INRet still wins by the reported ~12% margin, the Tab. 1 comparison stands; if the gap collapses or reverses, the headline accuracy advantage is attributable to the input INR architecture rather than to INRet's embeddings.","verdict_should_be":"CONDITIONAL","load_bearing_attack":"The paper claims INRet is 'more general and accurate than the existing INR retrieval method.' The headline evidence is Tab. 1, where INRet is applied to NGLOD/EG3D/iNGP grid INRs while inr2vec is applied to a separately trained MLP-only SIREN INR. This is not a like-for-like comparison. The paper's own reconstruction-quality measurements (Tab. 15) show grid INRs are substantially better than MLP INRs (C.D. ~0.012-0.022 vs. ~0.034-0.039), and Tab. 16 shows retrieval accuracy tracks reconstruction quality: an undertrained 2-epoch iNGP INR (C.D. 0.0371, close to the MLP's 0.0354) drops to 78.8 mAP from 84.2 for the fully trained iNGP, still above but much closer to inr2vec's 73.4. Thus the 12.0% gap in Tab. 1 is plausibly driven by the higher fidelity of grid-based INRs, not by a superior retrieval mechanism. A second, related concern is the architecture-specificity of the grid sampling in Sec. 3.2: Tab. 14 shows that switching from summation to concatenation for NGLOD drops accuracy by 14.8%, and switching from concatenation to summation for iNGP drops it by 53.8%. This means the Conv3D encoder does not extract a representation-agnostic geometric signature; it is tightly coupled to each grid's native feature-combination convention. That weakens the generality claim for future or unusual grid architectures unless a new encoder is trained for each convention. Neither issue invalidates the core method, and the internal ablations of the cross-implicit-function regularization (Tab. 4) are clean, but the headline accuracy comparison overstates what is currently demonstrated.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes INRet, a framework for retrieving 3D shapes that are represented as implicit neural representations (INRs). The method encodes both the MLP weights and the feature grid of an INR into an embedding via an MLP encoder and a Conv3D encoder, respectively, and uses cosine similarity between embeddings for retrieval. To support different implicit functions (SDF, UDF, occupancy), the authors train separate encoders and add two regularizations: an L2 loss that pulls together embeddings of the same shape across implicit functions, and a unified shape decoder that predicts a single implicit function from all embeddings. Experiments on ShapeNet10 and Pix3D compare INRet against inr2vec, PointNeXt, and View-GCN, including cross-architecture retrieval via INR distillation and extensive ablations over design choices. The paper also analyzes the relationship between reconstruction quality and retrieval accuracy.","tokens_in":23876,"tokens_out":5312,"duration_ms":44363,"significance":"The core contribution is timely and practically relevant: it is, to my knowledge, the first INR retrieval method that directly handles feature-grid-based INRs (octree, triplane, hash grid) and enables retrieval across different implicit functions, avoiding explicit conversion to point clouds or images. The paper is unusually thorough in its ablations (e.g., unified decoder choice, L2 weighting, norm choice, feature combination sensitivity, reconstruction quality analysis), and it honestly reports failure cases and the limited performance on the proposed Category-Chamfer metric. If the headline claims survive a fair architecture-matched comparison, INRet would be a solid benchmark for INR retrieval.","major_comments":[{"comment":"The headline comparison confounds retrieval method with INR architecture. INRet is evaluated on NGLOD/EG3D/iNGP grid-based INRs, while inr2vec is evaluated on MLP-only SIREN INRs. The reconstruction-quality measurements in Tab. 15 show that the grid-based INRs are substantially more accurate (C.D. 0.012–0.022 vs 0.034–0.039 for MLP), and Tab. 16 shows that when iNGP is undertrained to 2 epochs (C.D. 0.0371, close to the MLP's 0.0354), its mAP drops from 84.2 to 78.8, still above but much closer to inr2vec's 73.4. This suggests the reported 12.0% accuracy gain may largely reflect representation quality rather than a superior retrieval mechanism. Please add a like-for-like comparison: e.g., INRet on MLP-only INRs (as in Tab. 10) and inr2vec on grid-based INRs if it can be adapted, or at least an ablation that controls for reconstruction quality (e.g., matching C.D. across compared architectures).","section":"§5.2, Tab. 1"},{"comment":"The generality claim for arbitrary grid architectures is undermined by the sensitivity of the Conv3D encoder to the native feature-combination convention. Switching from summation to concatenation for NGLOD drops mAP from 82.6 to 67.8 (a 14.8-point drop), and switching from concatenation to summation for iNGP drops it from 84.2 to 30.4 (a 53.8-point drop). This indicates that the encoder learns a representation that is tightly coupled to the specific grid's feature-combination rule, rather than a representation-agnostic geometric signature. The claim in §3.2 that 'a similar feature grid sampling approach can be used to also train an encoder for any new grid-based architecture' should be qualified, and the paper should discuss whether the encoder needs retraining for each new combination convention.","section":"§3.2, Tab. 14"},{"comment":"The headline improvement numbers are internally inconsistent and do not match Tab. 1. The abstract states a 10.1% average improvement and the conclusion repeats 'more than 10%'; §5.2 reports 12.0% higher accuracy than inr2vec for iNGP, which itself differs from the 10.8-point gap in Tab. 1 (84.2 vs 73.4 on ShapeNet10). Please state the exact numbers, specify whether the figures are percentage points or relative percentages, and recompute the average from the tables.","section":"Abstract and §5.2"},{"comment":"No error bars or statistical significance tests are reported, and no code is provided. Since ShapeNet10 has only 50 test shapes per category and retrieval results are reported at a single seed, the 5–10 point gaps against baselines could be within run-to-run variance. Please report results over multiple seeds (at least for the main tables) or release code to make the numerical claims reproducible.","section":"All tables"}],"minor_comments":[{"comment":"The phrase '12.0%, 15.4%, and 12.6% higher accuracy' should be clarified as percentage-point differences rather than relative improvements, since the compared mAP values are already percentages.","section":"§5.2"},{"comment":"The loss in Eq. (4) is written with an absolute value where an L1 norm is intended; please define the norm explicitly and distinguish the L1 loss for the unified decoder from the L2 regularization term in the same equation.","section":"Eq. (4)"},{"comment":"The legend explaining the multiple numbers per cell is given only in the table text, not in the caption; please include it in the caption so the reader can interpret the entries without scanning the body text.","section":"Tabs. 3 and 7"},{"comment":"The paper reports that INR distillation introduces approximately 30 seconds of overhead; please state whether this is a one-time cost per query or per INR, and clarify how it should be weighed against the retrieval latencies in Tab. 1.","section":"§5.3"},{"comment":"The sampling resolution N for the Conv3D encoder is a free parameter, but no sensitivity analysis with respect to N is reported; a brief ablation or a justification for the chosen value would strengthen the presentation.","section":"§3.2"},{"comment":"The sentence 'The encoders take MLP weights and feature grid parameters as inputs to generate the INR Embedding' is slightly misleading because the decoder is used only during training; please rephrase to make clear that the decoder is not used at inference.","section":"Fig. 1 caption"}],"recommendation":"major_revision","confidential_remarks":"The main risk is the architecture confound in Tab. 1; the paper would be substantially stronger with an architecture-controlled comparison and with code or error bars. The cross-implicit regularization is admittedly partly by construction, but the ablations and test-set results make it a legitimate contribution, so I would not reject on those grounds. The paper's breadth of ablations is a real strength, and the honesty about the Category-Chamfer metric's limitations is welcome."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"You should read this paper if you care about organizing INR databases. It is the first retrieval method that handles modern feature-grid INRs (NGLOD, EG3D, iNGP) and the first to retrieve across SDF, UDF, and occupancy. That is the real news. The design is straightforward: an MLP encoder over the INR weights plus a Conv3D encoder over a fixed-resolution sampling of the feature grid, with an L2 loss and a unified decoder to align embeddings across implicit functions. The components are extensions of inr2vec, but the combination is new and the ablations are fairly clean.\n\nThe paper earns credit for its internal evaluation. The cross-implicit-function results are supported by careful ablations (Tab. 4) and robustness checks on the unified decoder's output type and L2 weighting. The appendices report reconstruction quality, feature-combination sensitivity, and a new Category-Chamfer metric with a hierarchical sampling trick that actually works. That is honest, reproducible work in spirit, though no code is released.\n\nThe main soft spot is the headline comparison in Tab. 1. INRet is evaluated on grid-based INRs while inr2vec is evaluated on an MLP-only SIREN INR. The stress-test note is right: Tab. 15 shows grid INRs reconstruct shapes substantially better than the MLP INR, and Tab. 16 shows retrieval accuracy drops when an iNGP is undertrained to MLP-level reconstruction quality. The 12% gap is therefore not a clean measure of the retrieval method; it partly reflects the better input representation. The iNGP@2epoch result (78.8 vs 73.4) narrows the gap but doesn't eliminate the confound, because the architectures still differ. The reported improvement is also inconsistent (10.1% in the intro vs 12.0% in Sec. 5.2) and there are no error bars. That is sloppy but fixable.\n\nA second point: Tab. 14 shows the Conv3D encoder is tightly coupled to each grid's native feature-combination convention (sum vs concat). Switching conventions collapses accuracy. So the generality is 'one encoder per grid convention', not a single representation-agnostic encoder. The paper does acknowledge this in Sec. 3.2, so it isn't deceptive, but the abstract's 'general' should be read with that caveat.\n\nNone of this sinks the core method. The cross-implicit alignment via L2 + unified decoder is a sound idea and the test-set evidence is not circular. The paper deserves a serious referee. I would ask for a like-for-like comparison (e.g., run inr2vec on grid INRs if possible, or run INRet on MLP-only INRs without distillation), error bars, code release, and a rewritten headline claim. Then I'd be comfortable with it.","headline":"First real retrieval method for grid-based INRs with clean cross-implicit ablations, but the headline accuracy comparison is confounded by architecture and needs a like-for-like rerun.","tokens_in":24503,"tokens_out":2997,"would_cite":true,"duration_ms":27575,"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":"INRet finds similar 3D shapes directly from neural-field encodings.","keywords":["implicit neural representation","3D shape retrieval","feature grids","octree","triplane","hash grid","shape embedding","signed distance function"],"falsifier":"Take a pair of different shapes whose feature grids agree at the chosen $(2N)^3$ sampling locations, for instance two objects that differ only in a thin region between grid points, and train INRs for them; if INRet ranks this pair as near-duplicates while a higher-resolution sampling or a point-cloud conversion separates them cleanly, the fixed-resolution sampling is the failure point. A quantitative version is to measure mAP@1 as $N$ grows: if accuracy is still improving at the largest practical $N$, the fixed resolution is a ceiling on the method rather than a neutral implementation detail.","tokens_in":23318,"feed_emoji":"🧊","tokens_out":7403,"duration_ms":64512,"temperature":0.7,"pith_summary":"INRet sets out to answer a practical question: once 3D shapes are stored as implicit neural representations (INRs), how do you retrieve similar shapes from a data store? The paper claims that similarity can be computed directly from the INR itself, using both its MLP weights and its learned feature-grid parameters, instead of converting the INR to a point cloud or multi-view images. The method targets the feature-grid architectures used in practice today, namely octree, triplane, and hash grids, and it is designed to handle the three common implicit functions: signed distance, unsigned distance, and occupancy. If correct, this means an INR data store can be searched by another INR, even across different architectures and different implicit functions, with higher accuracy than conversion-based retrieval and with much lower latency. On ShapeNet10 and Pix3D, grid-based SDF INRs reach 82–84% and 74–78% mAP@1, respectively, roughly 12–15% above the inr2vec, PointNeXt, and View-GCN baselines for iNGP INRs.","feed_headline":"INRet finds similar 3D shapes directly from neural-field encodings","feed_subtitle":"Works across octree, triplane and hash-grid INRs and across SDF, UDF and occupancy fields.","key_machinery":"The load-bearing object is the INR Embedding Encoder, composed of an MLP encoder for the INR's network weights and a Conv3D encoder for its feature grid. For the grid, the paper samples $(2N)^3$ feature vectors at a fixed resolution, summing features across octree or triplane levels with zero-filling for missing voxels, or reading hash-grid features through the original hash function, then passes the sampled volume through 3D convolutions. The second mechanism is the unified latent space: an explicit L2 loss and a Unified Shape Decoder force embeddings from different implicit functions of the same shape to converge to one representation, so cosine similarity in that space can be compared across SDF, UDF, and occupancy INRs.","core_discovery":"The central claim is that a shape INR can be converted into a fixed-length embedding that preserves enough information for accurate retrieval by encoding the INR's MLP weights with an MLP encoder and encoding a fixed-resolution sample of its feature grid with a Conv3D encoder, then concatenating the two. To make embeddings comparable across implicit functions, the paper trains separate encoders per implicit function and regularizes them in two ways: an explicit L2 loss pulls embeddings of the same shape together across SDF, UDF, and occupancy representations, and a single Unified Shape Decoder supervises all three encoders to reconstruct one common implicit function. The paper claims this enables accurate retrieval across grid architectures and implicit functions, and reports that it outperforms the prior INR-retrieval method inr2vec, which only supports MLP-only INRs with matching architectures, as well as point-cloud and multi-view-image retrieval on converted INRs.","pith_inferences":["A consequence the authors leave implicit is that the fixed-resolution grid sampling defines, in effect, a canonical tensor view of a broad family of grid INRs, so the same Conv3D encoder could be reused for any future grid whose features can be sampled the same way.","The paper's appendix shows that cosine-similarity embeddings score only 21–28% on its own Category-Chamfer metric, which rewards retrieving the exact instance with smallest Chamfer distance rather than just the same category; this suggests the central claim is best read as category-level semantic retrieval, with instance-level geometric matching left as an open problem.","The cross-architecture results imply that retrieval accuracy depends on respecting each architecture's native feature-combination rule: summing iNGP hash-grid features instead of concatenating them drops mAP from 84.2 to 30.4, so future encoders should preserve each grid's original aggregation rather than imposing one rule.","An untested extension is to vary the sampling resolution $N$ and measure mAP: if accuracy keeps rising with $N$, the fixed resolution is the bottleneck, and if it saturates early, the encoder or the INR representation itself is the limiting factor."],"forward_implications":["An INR data store can be searched directly with an INR query, avoiding point-cloud or multi-view conversion and cutting retrieval latency by one to two orders of magnitude in the no-conversion case.","Retrieval works across feature-grid architectures: a query MLP-only INR can be distilled into a supported grid architecture and still retrieve NGLOD, EG3D, or iNGP INRs with accuracy comparable to or better than inr2vec.","With both regularizations, querying a UDF, SDF, or occupancy INR retrieves INRs of all three types at roughly the same accuracy as same-type retrieval, about 82% average for iNGP on ShapeNet10, whereas inr2vec drops to near 10% for cross-type retrieval.","Because grid-based INRs reconstruct shapes more faithfully than MLP-only INRs, retrieval built on them inherits that fidelity; the paper shows even under-trained iNGP INRs outperform MLP-only INRs in retrieval accuracy.","New grid-based INR architectures can be supported either by training an analogous sampling-based encoder or by distilling the new architecture into a supported one."],"supporting_citations":[{"why":"The inr2vec baseline: prior INR retrieval that encodes MLP weights only and requires matching architectures between query and stored INRs; it also supplies the MLP encoder and training recipe INRet builds on.","marker":"[13]"},{"why":"Defines NGLOD octree-grid INRs, one of the three supported architectures, and the sampling and training conventions used to generate SDF INRs.","marker":"[42]"},{"why":"Defines iNGP multi-resolution hash grids; INRet samples features through the original hash function and reports its highest retrieval accuracy on this architecture.","marker":"[29]"},{"why":"Defines EG3D triplane INRs, the third supported grid architecture.","marker":"[4]"},{"why":"Establishes unsigned distance fields and the damped spherical tracing used to convert UDF INRs and to supervise the Unified Shape Decoder.","marker":"[11]"},{"why":"Establishes occupancy fields and the isosurface-extraction route used when converting occupancy INRs to point clouds and images.","marker":"[25]"},{"why":"Introduces SDF-based shape INRs, motivating the need for retrieval across implicit functions.","marker":"[30]"},{"why":"PointNeXt baseline: point-cloud retrieval on INRs converted to point clouds, against which INRet reports an accuracy improvement.","marker":"[35]"},{"why":"View-GCN baseline: multi-view-image retrieval on rendered INR views, against which INRet reports an accuracy improvement.","marker":"[48]"}],"fun_headline_variants":["INRet retrieves similar 3D shapes from neural-field codes","Shape-INR retrieval that spans octree, triplane, and hash grids","INRet's embedding aligns shape INRs across implicit functions","Match 3D shapes encoded as INRs with INRet's embeddings","INRet: general retrieval for shape neural representations"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is that a fixed-resolution $(2N)^3$ sampling of the feature grid, with octree levels summed, missing voxels zero-filled, and hash or triplane grids read through their native lookups, keeps enough geometric information to tell different shapes apart; if that sampling loses the discriminating detail or makes different architectures look alike, the Conv3D encoder cannot build comparable embeddings.","fun_headline_variants_meta":{"raw":{"variants":["INRet retrieves similar 3D shapes from neural-field codes","Shape-INR retrieval that spans octree, triplane, and hash grids","INRet's embedding aligns shape INRs across implicit functions","Match 3D shapes encoded as INRs with INRet's embeddings","INRet: general retrieval for shape neural representations"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000446,"raw_usage":{"total_tokens":2288,"prompt_tokens":1012,"completion_tokens":1276,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":628,"completion_tokens_details":{"reasoning_tokens":1188}},"tokens_in":628,"tokens_out":1276,"duration_ms":11802,"temperature":1.0,"reasoning_tokens":1188,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-10T14:00:43.605485+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Take a pair of different shapes whose feature grids agree at the chosen $(2N)^3$ sampling locations, for instance two objects that differ only in a thin region between grid points, and train INRs for them; if INRet ranks this pair as near-duplicates while a higher-resolution sampling or a point-cloud conversion separates them cleanly, the fixed-resolution sampling is the failure point. A quantitative version is to measure mAP@1 as $N$ grows: if accuracy is still improving at the largest practical $N$, the fixed resolution is a ceiling on the method rather than a neutral implementation detail.","supporting_citations":[{"cited_title":"Deep learning on implicit neural representations of shapes","cited_arxiv_id":null,"evidence_quote":"The inr2vec baseline: prior INR retrieval that encodes MLP weights only and requires matching architectures between query and stored INRs; it also supplies the MLP encoder and training recipe INRet builds on."},{"cited_title":"Neural geometric level of detail: Real-time rendering with implicit 3d shapes","cited_arxiv_id":null,"evidence_quote":"Defines NGLOD octree-grid INRs, one of the three supported architectures, and the sampling and training conventions used to generate SDF INRs."},{"cited_title":"Instant neural graphics primitives with a mul- tiresolution hash encoding","cited_arxiv_id":null,"evidence_quote":"Defines iNGP multi-resolution hash grids; INRet samples features through the original hash function and reports its highest retrieval accuracy on this architecture."},{"cited_title":"Lin, Matthew Chan, Koki Nagano, Boxiao Pan, Shalini De Mello, Orazio Gallo, Leonidas J","cited_arxiv_id":null,"evidence_quote":"Defines EG3D triplane INRs, the third supported grid architecture."},{"cited_title":"Occupancy networks: Learning 3d reconstruction in function space","cited_arxiv_id":null,"evidence_quote":"Establishes occupancy fields and the isosurface-extraction route used when converting occupancy INRs to point clouds and images."},{"cited_title":"Deepsdf: Learning con- tinuous signed distance functions for shape representation","cited_arxiv_id":null,"evidence_quote":"Introduces SDF-based shape INRs, motivating the need for retrieval across implicit functions."},{"cited_title":"View-gcn: View- based graph convolutional network for 3d shape analysis","cited_arxiv_id":null,"evidence_quote":"View-GCN baseline: multi-view-image retrieval on rendered INR views, against which INRet reports an accuracy improvement."}],"review_version":1}