PaperlayerView exact revision on arXiv

Source-linked AI summary

H3DNAS: Hardware-Aware ONNX-Native 3D Point Cloud Model Compression

Anchit Mulye, Rhythm Baghel, Sujay Kumar Ingle, Hardik Jain

arXiv:2609.02684v1cs.LGcs.ARcs.NE

TL;DR

Edge deployment of 3D point-cloud models is constrained, while existing compression methods generally require unavailable source code. H3DNAS performs hardware-aware search and compression directly on ONNX graphs, combining topology-based dependency analysis with two-stage pruning and mutation. On ModelNet40, it reports substantial parameter reductions and speedups with negligible accuracy loss, while its scope includes operator and reconstruction limitations.

  • Problem

    Existing NAS and structured compression methods require source code or framework access, limiting their use on vendor-distributed ONNX binaries.

  • Method

    H3DNAS derives dependency constraints from ONNX topology, uses L1 pruning and output-fidelity screening, and applies GhostConv mutations to hardware-feasible candidates.

  • Results

    On ModelNet40, H3DNAS reduces parameters by 65.5% for PointNet, 43.2% for PointNet++, and 49.1% for PointMLP, with 1.99×, 1.29×, and 1.67× speedups, respectively.

  • Takeaways & Limitations

    H3DNAS provides a source-code-free compression pipeline for 3D point-cloud ONNX models and uses ρf to assess channel-pruning feasibility before search.

  • Takeaways & Limitations

    Supported operators and reconstruction patterns constrain portability: unsupported onnx2torch operators error, custom PTv3 exports need manual registration, and reconstructed names differ.

Abstract

from arXiv · show

Deploying 3D point cloud models on edge hardware such as the NVIDIA Jetson Orin Nano is severely constrained by compute and memory budgets. Existing compression methods require access to the model's original source code, rendering them inapplicable to the Open Neural Network Exchange (ONNX) binaries commonly distributed by vendors and model repositories. We present \textbf{H3DNAS}, a hardware-aware model compression framework that operates directly on ONNX computational graphs without requiring original source code, architecture class definition, or gradient access during search. H3DNAS makes three contributions: (1) a \textbf{Channel Dependency Graph (CDG)} that classifies ONNX operators into four constraint classes and formally establishes that the free parameter fraction $ρ_f$ is topological invariant, a provable compression ceiling computable in $\mathcal{O}(|V|+|E|)$; (2) a \textbf{Two-Stage Hierarchical Search} that prunes candidate architectures by $L_1$-importance channel selection, ranks them by output fidelity as a zero-shot label-free proxy, and applies GhostConv structural mutation to Pareto-optimal candidates; and (3) the \textbf{first source-code-free compression pipeline for 3D point cloud models}, operating entirely via ONNX graph surgery with no original architecture definition required. On ModelNet40, H3DNAS reduces the number of parameters in PointNet, PointNet++, and PointMLP by $65.5\%$, $43.2\%$, and $49.1\%$, respectively, while achieving $1.99\times$, $1.29\times$, and $1.67\times$ inference speedups with negligible loss in accuracy. The source code is publicly available\footnote{https://github.com/ClarityLab-Org/h3dnas}.

1. Introduction

H3DNAS addresses the lack of source-code-free compression for vendor-supplied ONNX models by performing hardware-aware search and graph surgery directly on ONNX representations.

  • Motivation: ONNX deployment creates a barrier because existing NAS and pruning methods require source code, framework APIs, named modules, backward passes, or architecture registries.This limitation affects models distributed by hardware vendors, repositories, and cross-framework collaborators.
  • H3DNAS: H3DNAS reads, mutates, prunes, evaluates, and ranks ONNX candidates without invoking training-framework APIs.The ONNX ModelProto is treated as the primary object throughout the compression process.
  • Novelty: H3DNAS is presented as the first source-code-free hardware-aware NAS framework applied to 3D point-cloud ONNX models.The framework targets PointNet, PointNet++, and PointMLP from ONNX alone.
  • Core contributions: The CDG theorem makes the free parameter fraction a topology-derived compression ceiling computable in O(|V| + |E|) time.The ceiling is intended to assess feasibility before search begins.
  • Core contributions: Two-stage search uses L1-importance pruning and output-fidelity ranking before applying GhostConv mutations to Pareto-optimal candidates.Output fidelity is computed as cosine similarity between baseline and candidate logits on random inputs, providing a zero-shot, label-free proxy.

3. The H3DNAS Framework

The H3DNAS framework derives valid pruning constraints from ONNX graph structure, estimates compression feasibility, and searches candidates through structured pruning, fidelity screening, and GhostConv mutation.

  • Graph representation: An ONNX model is represented as a directed acyclic graph whose nodes are operators, edges are tensors, and initializers contain weights.Shape inference annotates tensor edges with concrete dimensions without executing the model.
  • Channel Dependency Graph: The CDG connects convolution and Gemm nodes whose channel dimensions must match for ONNX Runtime validity, identifying singleton components as freely prunable.Operator classes and graph connectivity determine the dependency structure.
  • Constraint rules: Five constraint rules capture static shape terminators, dynamic tensor equality, grouped-convolution immutability, semantic output fixity, and learned-normalisation locks.These rules are derived from ONNX operator constraints and validated across five architectures.
  • Compression ceiling: ρf(G) depends only on graph topology and bounds channel-pruning reduction on a fixed-width base graph.Width scaling creates a modified graph G′ with a distinct ρf(G′), so reductions beyond the original ceiling do not violate the theorem.
  • Compression feasibility: CDG construction and independent free-node pruning require O(|V| + |E|) time, enabling rapid feasibility assessment before architecture search.For PointNet, 57.6% reduction is achieved against ρf = 58.1%; the analysis runs in under one second on any ONNX file.
  • Search pipeline: Stage 1 applies width multipliers and L1-guided channel pruning, then pre-screens candidates using logit cosine similarity on 32 random inputs.The top-K candidates proceed to evaluation, while Stage 2 applies GhostConv mutations to selected Pareto candidates.

4. Experiments

Experiments evaluate H3DNAS on ONNX-exported PointNet, PointNet++ SSG, and PointMLP using ModelNet40 and Jetson Orin Nano constraints. The results validate topology-based analysis, demonstrate architecture-dependent search behavior, and show substantial compression with speedups and small accuracy changes.

  • Experimental setup: Evaluation uses PointNet, PointNet++ SSG, and PointMLP on ModelNet40, with ONNX files used throughout search, compression, evaluation, and fine-tuning.The benchmark contains 9,843 training and 2,468 test samples across 40 classes, with 1,024 points per cloud.
  • Experimental setup: Search combines evolutionary pruning and width exploration, output-fidelity screening, Pareto selection, and GhostConv mutation under hardware constraints.Stage 1 uses prune ratios [0.05–0.50] and width multipliers [0.5–1.0]; top-15 candidates proceed to full accuracy evaluation.
  • CDG validation: O(|V| + |E|) CDG analysis computes topology-only compression information without trained weights, calibration data, or model execution.The free/constrained partition remains unchanged after pruning, while GhostConv can change ρf by approximately 0.03–0.05 through new channel couplings.
  • Main results: 65.5% parameter reduction and 1.99× speedup are achieved for PointNet with a −0.04 pp accuracy change.This is described as near-lossless compression at the reported compression level.
  • Main results: 43.2% parameter reduction and 1.29× speedup are achieved for PointNet++ SSG with +0.08 pp accuracy, while PointMLP reaches 49.1% reduction and 1.67× speedup with 93.11% accuracy (−0.28 pp).The PointNet++ result is reported as super-baseline and consistent with CP3 despite using the ONNX file alone.
  • Hardware feasibility: H3DNAS finds a PointNet model satisfying all four Jetson constraints, with latency headroom of +85.2% under the 50 ms budget.The base PointNet violates three of four constraints, whereas hardware checking is integrated directly into the search loop.

5. Discussion

H3DNAS uses ONNX graph topology to enable framework-agnostic compression and assess feasibility before search. Its current hardware and mutation support leave direct Jetson GPU profiling and deeper structural optimization for future work.

  • Framework-Agnostic Operation: H3DNAS derives a valid compression search space entirely from ONNX graphs, without invoking framework APIs during search.This supports vendor-supplied models, cross-framework checkpoints, and ONNX binaries with unavailable training code.
  • Compression Feasibility: The free parameter fraction ρ_f provides an immediate FLOPs-reduction bound and can redirect infeasible pruning cases toward quantization.When ρ_f < 10%, channel pruning is unlikely to yield meaningful compression.
  • Architecture Insights: Theorem 1 identifies three topology-based compression regimes, from nearly fully compressible CNNs to severely constrained mobile architectures.The reported ranges are approximately 99% freedom for simple CNNs, 28–58% for residual models, and 4–12% for mobile-optimized models.
  • Limitations: Current limitations include CPU-based primary latency ranking, support for only Level 1 graph mutations, and exclusion of gradient-based architecture optimization.On-device profiling would strengthen hardware claims, while Level 2 mutations requiring weight re-initialization remain future work.

6. Conclusion & Future Work

H3DNAS provides source-code-free, ONNX-only hardware-aware NAS for 3D point cloud models. On ModelNet40, it achieves substantial structured compression and speedups across PointNet, PointNet++ SSG, and PointMLP while preserving or improving reported accuracy.

  • Conclusion: H3DNAS is the first hardware-aware NAS framework for 3D point cloud models operating entirely from ONNX graphs without source code.The method requires no architecture definition or training framework API.
  • ModelNet40 Results: 65.5% parameter reduction and 1.99× speedup are achieved for PointNet with a −0.04 pp accuracy change.The result is described as near-lossless compression.
  • ModelNet40 Results: 43.2% parameter reduction and 1.29× speedup are achieved for PointNet++ SSG with a +0.08 pp accuracy change.The compressed model surpasses its uncompressed baseline in the reported result.
  • ModelNet40 Results: 49.1% parameter reduction is achieved for PointMLP at 93.11% accuracy, a −0.28 pp change, while outperforming prior PointMLP compression methods.Under Jetson Orin Nano 8GB constraints, H3DNAS delivers a 1.67× CPU speedup with 57.6% parameter reduction.

7. CDG Operator Classification and Constraint Rules

The CDG classifies ONNX operators exhaustively and converts those classifications into locking rules that preserve graph validity during pruning. These rules also expose when channel pruning is inappropriate, such as for attention heads.

  • Operator Classification: Table 9 enumerates 34 ONNX operators and assigns every operator to exactly one CDG constraint class.The classification is implemented as OP CLASS in the channel dependency graph parser.
  • Constraint Rules: Table 10 formalizes five locking rules, R1–R5, that encode the ONNX contracts enforced by the operator classification.The rules list the architectures in which each constraint fires.
  • Attention Constraints: R1 and R2 explain why per-channel pruning fails for attention QKV projections with fixed head reshaping and dynamic Q·K^T multiplication.The appropriate pruning granularity is the attention head rather than an individual channel.

8. CDG Compression Regime Analysis

CDG topology separates models into highly, moderately, and near-incompressible regimes, while structured ONNX pruning yields hardware-relevant reductions. The reported comparisons distinguish genuine weight compression from sparsity, redesign, or input reduction.

  • Regime 1 - Highly Compressible: PointNet and PointNet++ fall in the highly compressible regime, with ρ_f values of 58.1% and 61.4% and super-baseline accuracy after compression.Global max-pooling is the dominant constraint for these convolution-based backbones.
  • Regime 2 - Moderately Compressible: PointMLP is moderately compressible at ρ_f ≈47%, where dense residual Add constraints bound the free set and Stage 1 is preferred.The Stage 1 preference is attributed to the reported ablation study.
  • Regime 3 - Near-Incompressible: PCT and PTv3 are near-incompressible at ρ_f values of 12.3% and 7.0% because attention QKV projections lock almost all layers.CDG redirects these cases toward head pruning or quantization before compression experiments.
  • Compression Interpretation: ρ_f is a topological safety invariant rather than a strict compression ceiling, because pruning a free Cout also removes downstream coupled Cin columns.Consequently, realized reduction can exceed ρ_f.
  • Compression Comparisons: Structured pruning removes channels, filters, or layers to produce dense subnetworks with real commodity-hardware acceleration, unlike unstructured weight sparsity.Unstructured pruning preserves tensor dimensions, so theoretical FLOPs and actual latency remain unchanged without specialized sparse hardware.
  • Compression Comparisons: H3DNAS performs structured weight compression directly on the original PointMLP ONNX graph, achieving 49.1% parameter reduction at −0.28 pp accuracy loss.This differs from prior entries based on pre-designed models, knowledge distillation, or input-point reduction.
  • Hardware Evaluation: Primary latency ranking uses ORT CPU execution, while TensorRT FP16 on-device validation reports smaller but consistent 1.03× to 1.45× speedups.The GPU results corroborate the CPU-measured trends.

10. Engineering Challenges and Implementation Notes

The implementation validates H3DNAS across ONNX export, pruning, inference, and baseline-comparison conditions, while exposing model-specific constraints that limit some compression cases.

  • Deterministic Evaluation: 0.28pp accuracy divergence between PyTorch and ONNX Runtime arises from random farthest-point sampling, corrected by deterministic arange sampling.The patch is applied in both export and evaluation.
  • Export Constraints: PTv3 compression is deferred because pruning channel dimension C leaves stale Reshape Constant nodes and causes ONNX Runtime shape mismatches.The proposed fix scans and updates Constants containing C, but is not yet implemented.
  • Channel Alignment: L1-ranked non-contiguous channels require BatchNorm slicing by the selected cout index array rather than naïve positional truncation.This prevents channel-order mismatches after pruning.
  • Export Constraints: The nofold opset-13 export variant is used because folded exports insert Transpose and Reshape nodes that disrupt CDG constraint patterns and channel tracking.Export format therefore affects dependency analysis and pruning consistency.
  • Pruner Applicability: ONNXPruner produces invalid PointNet graphs because its traversal omits ReduceMax and MatMul constraints, whereas H3DNAS classifies both before pruning.The omitted operators govern the PointNet STN constraint pattern, R1+R2.
  • Reconstruction Limits: Successful reconstruction covers all three main architectures, but unsupported operators, custom PTv3 patterns, and changed generated layer names remain limitations.Custom PTv3 exports require manual operator registration.

12. Extended Results on 2D CNN Architectures

Extended validation applies CDG analysis and pruning to 29 ONNX Model Zoo architectures across seven architecture families, testing feasibility and safety under aggressive pruning.

  • Architecture Coverage: H3DNAS covers six representative 2D CNN designs spanning plain, residual, depthwise-separable, and Fire-module architectures.The complete validation comprises 29 models.
  • Full Validation: 29 ONNX Model Zoo architectures are evaluated at a 50% prune ratio without fine-tuning, with three models skipped because of quantization or absent Conv/Gemm nodes.The analysis reports CDG-free nodes, free parameter fraction, and the difference between achieved reduction and ρf.
  • Safety Validation: Zero crashes occur across 7 architecture families, and all 29 prunable models emit ONNX Runtime-valid graphs after session loading and forward passes.A safety backstop reverts failed candidates to the unpruned graph.
  • Safety Validation: 3 models trigger the safety backstop because a 50% cut is structurally unsatisfiable, while 4 further models retain every channel with 0% reduction but valid graphs.The affected models are ResNet50-v2, ShuffleNet-9, and GPT-2.
  • Compression Bounds: ρf is a safety invariant rather than a compression ceiling because pruning free Cout can also remove downstream coupled Cin columns.SqueezeNet-1.1 rises from 8.3% to 28.3%, and Inception-v1 from 15.6% to 38.3%.

14. Code, Models and Reproducibility

The reproducibility package provides code, pre-compressed ONNX models, and evaluation scripts for the three main architectures and multiple execution providers.

  • Repository: Code, pre-compressed ONNX models, and evaluation scripts are provided through the project repository.The repository includes the resources needed to reproduce the reported pipeline.
  • Model Artifacts: Pre-compressed ONNX files are supplied for PointNet, PointNet++, and PointMLP in the models directory.Each architecture has a corresponding H3DNAS model file.
  • Evaluation: hardware_analysis.py reproduces latency, parameter, FLOPs, and accuracy measurements for any base/NAS ONNX pair without model source code.It supports ORT-CPU, ORT-CUDA, and TensorRT execution providers.
  • Evaluation: Latency and parameter measurements can run without a dataset using the base and NAS ONNX model paths.Accuracy evaluation additionally uses the ModelNet40 data path and class count.
  • Hardware Evaluation: TensorRT inference on Jetson Orin Nano 8GB is exposed through the hardware-analysis command.The command compares the base and H3DNAS ONNX models on the target edge platform.
Loading 2609.02684v1…