{"id":"2119874b-a346-4ff9-ab16-9d0331e4d779","arxiv_id":"2501.03830","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":4.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":3,"one_line_summary":"A mesh-native CNN with variable-size convolution regions and parallel face-collapse pooling achieves competitive classification with substantially lower memory use.","lead":"MeshConv3D runs neural networks directly on triangular meshes without remeshing, using a custom convolution and a face-collapse pooling step. It reports competitive classification accuracy on three benchmarks while using far less GPU memory than prior mesh networks.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The pooling target sizes T=400/300/200 are unreachable on the 500-face benchmark meshes if each pass removes about half the faces, making the described architecture and efficiency results irreproducible as written.","rationale":"The reader's weakest_assumption concerns the L2-distance pooling heuristic's ability to preserve discriminative information. That is a plausible design concern, but it is secondary: even a suboptimal heuristic still yields a well-defined algorithm. The more load-bearing problem is that the pooling operator as specified cannot simultaneously satisfy two of its own stated properties on the actual benchmark data: removing about half the faces per pass and producing meshes of size T=400/300/200 from 500-face inputs. This internal inconsistency affects both the architecture definition and the reported efficiency measurements, which are central to the paper's claim of minimized memory and computational load. If the first pass removes ~250 faces, the target of 400 remaining faces is never reached and the second and third pooling layers operate on different mesh sizes than described; if it removes only 100 faces, the 'about half' property and the associated parallelism argument lose force. Either way, the experimental setup is not reproducible from the text, and the Table III memory/runtime numbers cannot be attributed to the described network without additional clarification. This is a concrete, technical correctness issue rather than a stylistic or comparative concern. The verdict remains CONDITIONAL because the authors could plausibly resolve it by releasing code, reporting actual pooled sizes, and correcting the description of T; however, the condition is now more specific than the reader's request for ablations, since it demands internal consistency of the core operator before the efficiency claims can be accepted.","tokens_in":7772,"tokens_out":7752,"duration_ms":74431,"concrete_test":"Implement the pooling algorithm exactly as in Section III-C on one SHREC11 mesh (500 faces) with T=400, then T=300, T=200, and record the actual face count after each pooling layer. If the first layer yields fewer than 400 faces (e.g., ~250), the architecture description is invalid; if it yields exactly 400, then the 'approximately half' claim is false. Either outcome settles the inconsistency. Also report the actual pooled sizes for all three benchmarks and recompute Table III under those sizes.","verdict_should_be":"CONDITIONAL","load_bearing_attack":"The central claim depends on the face-collapse pooling operator (Section III-C). Steps 2–5 select mutually non-overlapping collapse regions and remove them in parallel, and the text states this simultaneously eliminates about half the faces per pass. Section IV-A sets target pooling sizes T=400, 300, and 200, 'expressed as number of remaining mesh faces after pooling'. All three benchmarks use meshes with exactly 500 faces. If the first pooling pass removes ~250 faces (half of 500), the mesh drops to ~250 faces, already below T=400; step 6 then stops because the size is no longer superior to T. The second and third pooling layers cannot act on meshes of 400 and 300 faces as the described VGG-like architecture requires. Conversely, if the network actually produces 400 faces after the first layer, then only 100 faces are removed, contradicting the 'about half' claim and weakening the stated parallel efficiency. Either way, the pooling operator and the architecture are not consistently specified. Since Table III's runtime and memory measurements were taken on this architecture, the efficiency and accuracy results are not reproducible from the paper alone. This is a correctness issue in the core operator, not merely a missing ablation.","agreement_with_reader":"disagree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper presents MeshConv3D, a convolutional and pooling framework that operates directly on triangular meshes. Convolution patches are built by iteratively expanding face neighborhoods to a user-defined kernel size K, and the convolution is an order-invariant sum of central and neighboring face descriptors (Eq. 4). Pooling greedily selects faces with the smallest L2 descriptor-distance to their neighbors (Eq. 5), collapses mutually compatible regions in parallel, and removes roughly half of the faces per pass. Classification experiments are reported on SHREC11, cubes, and Manifold40, together with runtime and GPU-memory comparisons against MeshCNN, MeshNet++, and SubdivNet.","tokens_in":8037,"tokens_out":4883,"duration_ms":46388,"significance":"If the reported behavior is reproducible, MeshConv3D would be a practically useful mesh-CNN building block: it avoids remeshing, supports variable receptive fields, and its pooling is parallel and removes many faces at once, addressing a known bottleneck of edge-collapse pooling. The paper builds on prior descriptors from ExMeshCNN rather than claiming a new descriptor, and the convolution and pooling definitions are simple and clearly specified at a conceptual level. The evidence, however, is underreported: no architecture or kernel-size specification, no ablations for the pooling criterion, and no variance information for the efficiency measurements. The manuscript is therefore a plausible incremental contribution whose empirical claims need substantial strengthening before the efficiency and accuracy conclusions can be accepted.","major_comments":[{"comment":"The pooling target sizes T=400, 300, and 200 are unreachable on the benchmark meshes, all of which have 500 faces, as they are described. Section III-C states that each pooling pass eliminates 'about a half' of the faces, and steps 5-6 stop as soon as the mesh size is no longer superior to T. Starting from 500 faces, the first pass would leave roughly 250 faces, already below T=400, so the second and third pooling layers could not operate on meshes of 400 and 300 faces as the VGG-like architecture in Section IV-A requires. If instead the network actually produces 400 faces after the first pooling, then only about 100 faces are removed, contradicting the stated half-face removal and the claimed parallel efficiency. The architecture and the pooling operator are thus not consistently specified, and the runtime and memory values in Table III are not reproducible from the paper alone.","section":"III-C and IV-A"},{"comment":"The manuscript never specifies the convolution kernel size K or the remaining network hyperparameters, such as the number of channels per block, the number of convolutional layers per block, activation, optimizer, learning rate, epochs, and training batch size. Because the convolution definition in Eq. (4) depends on K, and the VGG-like architecture is central to the accuracy results, the reported 100% scores on SHREC11 and cubes and 92.4% on Manifold40 cannot be reproduced or compared fairly from the text.","section":"III-B and IV-A"},{"comment":"The pooling significance criterion is asserted rather than validated. The only evaluation of the L2-distance heuristic is end-to-end accuracy on datasets where several methods saturate at 100% in Table I, which cannot discriminate among pooling strategies. An ablation comparing the proposed significance score with random pooling or with alternative criteria, such as learned significance scores, is necessary to support the claim that the pooling mechanism preserves discriminative information while removing half the faces per pass.","section":"III-C and Eq. (5)"},{"comment":"The efficiency comparison is underreported. The table gives a runtime ratio and peak memory for each competing method but no standard deviation, no description of the competing implementations' configurations, and no per-method breakdown of the pooling and convolution contributions. Since SubdivNet's runtime ratio is 0.87, the claim of superior efficiency is sensitive to implementation details; without more detail and error bars, the superiority conclusion is not established.","section":"IV-E and Table III"},{"comment":"The characterization of the Manifold40 results is imprecise: Table II reports 92.4% for MeshConv3D versus 93.6% for ExMeshCNN, which is a lower accuracy, and the surrounding text acknowledges this only indirectly. The abstract's phrase 'equivalent or superior classification results' is defensible for SHREC11 and cubes, but on Manifold40 the result is inferior to the closest competitor; the claim should be qualified accordingly.","section":"IV-D and Table II"}],"minor_comments":[{"comment":"The table formatting is inconsistent: for example, the MeshNet++ row shows '98,5' without a percent sign, and decimal commas should be unified throughout the tables.","section":"IV-D, Table I"},{"comment":"Reference [20] appears to point to Wu et al., 3D ShapeNets, but the cubes dataset is described as built from the MPEG-7 binary shape dataset; the citation should be verified and corrected if necessary.","section":"References"},{"comment":"The text uses 'efficacity' where 'efficacy' is intended; this and similar wording issues should be corrected.","section":"IV-E"},{"comment":"The color-based explanations in the captions are difficult to follow in a black-and-white rendering; adding explicit labels or a short textual description of which faces disappear would improve clarity.","section":"Figures 2 and 3"},{"comment":"The final paragraph contains a typo, 'more advances convolutional kernels', which should read 'more advanced convolutional kernels'.","section":"V"}],"recommendation":"major_revision","confidential_remarks":"The manuscript is within the scope of the journal, but the central experimental evidence is incomplete. In particular, the pooling target inconsistency in Section III-C versus Section IV-A makes the architecture as written unreproducible, and the missing hyperparameters and ablations weaken the accuracy and efficiency claims. I would encourage the editor to require the authors to provide the missing architecture details, correct the pooling target specification, and add the pooling-criterion ablation before further consideration."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Quick take: this paper has a useful idea buried under a reproducibility problem. The MeshConv3D pooling—selecting non-overlapping face-collapse regions greedily by a descriptor-distance heuristic and collapsing them in parallel—is genuinely more parallelizable than the sequential edge-collapse used in MeshCNN, and the variable-size convolution regions are a reasonable way to grow receptive fields without remeshing. The authors also compare against the right baselines and are honest that ExMeshCNN beats them on Manifold40 (92.4 vs 93.6), which the abstract's \"equivalent or superior\" claim doesn't quite cover.\n\nThe soft spots are real. The big one: the architecture says three pooling layers with target sizes T=400, 300, and 200, but all input meshes have 500 faces and each pooling pass removes \"about half\" of them. If the first pass takes 500 to ~250, the pool stops because 250 is below the 400 target. The second pool (T=300) is then a no-op, and only the third (T=200) does anything, to ~125. So the network is not the VGG-like stack the text describes, and the runtime/memory numbers in Table III were measured on something else. The paper doesn't explain this. It also gives no kernel size K, no channel counts for the conv blocks, no error bars on runtime or memory, and no code. For a paper whose headline is efficiency, that's a serious gap.\n\nThe pooling selection heuristic itself (L2 distance to neighbors as salience) is plausible but untested. There's no ablation against random pooling or a learned score, so I can't tell whether the greedy selection is doing any work for accuracy.\n\nBottom line: the core operators may be sound, but as written the paper is not reproducible enough to verify the central efficiency claim. I'd send it to peer review, because the parallel pooling idea deserves scrutiny and the flaws are fixable, but I'd expect a major revision—clarify the pooling semantics, report actual per-layer sizes, give full hyperparameters, add ablations, and release code. Without that, the efficiency numbers don't stand.","headline":"Plausible parallel mesh pooling idea, but the pooling sizes don't work on 500-face meshes and the efficiency numbers are therefore unverifiable as written.","tokens_in":8517,"tokens_out":5449,"would_cite":false,"duration_ms":47864,"reading_group":"maybe","serious_thinker":"no","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"MeshConv3D claims a CNN can learn directly on raw triangular meshes, matching prior accuracy at a fraction of the memory.","keywords":["3D mesh classification","mesh convolution","face collapse pooling","triangular meshes","local face descriptors","order-invariant convolution","GPU memory efficiency","deep learning on meshes"],"falsifier":"Run the same architecture on Manifold40 with the pooling faces chosen randomly instead of by the lowest L2 distance to neighbors. If random pooling reproduces the reported 92.4% accuracy, the paper's significance criterion is not doing the work; if accuracy drops sharply, the criterion is load-bearing.","tokens_in":7605,"feed_emoji":"🧊","tokens_out":9190,"duration_ms":86544,"temperature":0.7,"pith_summary":"The paper introduces MeshConv3D, a pair of neural-network operators—convolution and pooling—designed to run directly on triangular meshes without remeshing. It claims these operators let a VGG-style classifier match the best published mesh-classification accuracy on SHREC11 and the cube dataset, and reach 92.4% on Manifold40, while using about 682 MB of GPU memory at training time versus roughly 2.6 to 7.4 GB for comparable methods. If the claim holds, dense 3D meshes become tractable inputs for deep networks, because the costly remeshing that multiplies face counts is avoided.","feed_headline":"Mesh CNN matches best 3D classification scores at one-tenth memory","feed_subtitle":"Face-collapse pooling removes half the triangles per pass, so raw meshes need no remeshing.","key_machinery":"The central mechanism is the parallel face-collapse pooling operator driven by a descriptor-difference significance weight. For each face, the weight is computed as $w_f = \\sum_{n=1}^{3} \\lVert d_f - d_{f_n} \\rVert_2$, and the algorithm greedily selects faces with the lowest weight while marking overlapping candidates as incompatible, then collapses all selected regions in parallel. The second piece is the order-invariant convolution operation, which uses sums and absolute differences of neighboring face descriptors rather than imposing a fixed ordering on irregular neighborhoods, and whose kernel size $K$ controls how many rings of neighbors are included. Together these operators allow a standard convolutional architecture to run on native meshes.","core_discovery":"The central claim is that a mesh CNN can preserve discriminative face information while eliminating about half the faces per pooling step, if the faces to collapse are chosen by a simple local criterion. The pooling algorithm assigns each face a weight equal to the L2 distance between its descriptor and its three neighbors' descriptors, greedily selects non-conflicting faces with the lowest weights, and collapses all selected regions simultaneously, averaging the features of collapsed faces into the surviving faces. On SHREC11 and the cube dataset, the paper reports 100% accuracy in both tested splits; on Manifold40 it reports 92.4%, which is within the range of prior methods. The paper argues that these results are equivalent or superior to prior work while using substantially less GPU memory and computation.","pith_inferences":["A natural next step the paper does not take is to swap the L2-based pooling criterion for a learned significance score or a curvature-aware measure; if accuracy improves on Manifold40, the descriptor-difference heuristic, rather than the descriptors themselves, would be the limiting factor.","The efficiency comparison is measured at training time on 500-face meshes; on denser meshes the parallel face-collapse step should make the memory advantage grow, but the paper does not show such scaling.","Because the convolution and pooling operate on faces rather than vertices or edges, the same building blocks could be dropped into a segmentation or generative autoencoder, where hierarchical collapse is a natural encoder; the paper tests only classification."],"forward_implications":["Mesh classification can be run on native meshes, so the preprocessing pipeline no longer needs remeshing or conversion, removing a major source of memory overhead and potential distortion.","Because the pooling operator eliminates about half the faces per pass and computes many collapses at once, deeper networks can be trained on meshes that would otherwise exceed GPU memory.","The convolution layer is order-invariant and its receptive-field size is adjustable, so the same operator can be widened without redefining the neighborhood structure.","On the tested 500-face benchmarks, the reported accuracy is equal to or above that of prior methods, indicating that raw triangular face descriptors plus efficient pooling are sufficient for semantic classification."],"supporting_citations":[{"why":"It defines the geodesic and geometric face descriptors that the new convolution consumes.","marker":"[1]"},{"why":"It supplies the MeshCNN baseline, the cube dataset, and the SHREC11 train/test split protocol used in the experiments.","marker":"[3]"},{"why":"It introduces the Manifold40 benchmark and the subdivision-based remeshing approach whose high face counts motivate the memory comparison.","marker":"[4]"},{"why":"It proposes face-based convolution with face-collapse pooling, which is the closest methodological precedent for MeshConv3D.","marker":"[16]"},{"why":"It provides MeshNet++, a face-descriptor method compared in both the accuracy and peak-memory tables.","marker":"[17]"}],"fun_headline_variants":["MeshConv3D: face-collapse pooling, top accuracy at low memory","No remeshing, half faces per pool: MeshConv3D matches best","Memory-friendly mesh CNN: equivalent accuracy, fewer triangles","Collapse half the faces, keep the accuracy: MeshConv3D","Direct convolution on raw meshes: efficient pooling, top scores"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The entire efficiency story depends on the assumption that a face whose local descriptor is close to its three neighbors' descriptors is safe to collapse, and the paper offers no ablation comparing this rule with random or learned pooling.","fun_headline_variants_meta":{"raw":{"variants":["MeshConv3D: face-collapse pooling, top accuracy at low memory","No remeshing, half faces per pool: MeshConv3D matches best","Memory-friendly mesh CNN: equivalent accuracy, fewer triangles","Collapse half the faces, keep the accuracy: MeshConv3D","Direct convolution on raw meshes: efficient pooling, top scores"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000647,"raw_usage":{"total_tokens":2929,"prompt_tokens":861,"completion_tokens":2068,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":477,"completion_tokens_details":{"reasoning_tokens":1975}},"tokens_in":477,"tokens_out":2068,"duration_ms":15073,"temperature":1.0,"reasoning_tokens":1975,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-10T21:45:21.742387+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run the same architecture on Manifold40 with the pooling faces chosen randomly instead of by the lowest L2 distance to neighbors. If random pooling reproduces the reported 92.4% accuracy, the paper's significance criterion is not doing the work; if accuracy drops sharply, the criterion is load-bearing.","supporting_citations":[{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"It introduces the Manifold40 benchmark and the subdivision-based remeshing approach whose high face counts motivate the memory comparison."},{"cited_title":"Face-Based CNN on Triangular Mesh with Arbitrary Connectivity,","cited_arxiv_id":null,"evidence_quote":"It proposes face-based convolution with face-collapse pooling, which is the closest methodological precedent for MeshConv3D."}],"review_version":1}