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

AI summary

Overview

Research area: Hardware-aware neural architecture search, structured model compression, and 3D point cloud deep learning — specifically compression of ONNX binaries without source code.

Technical level: Advanced. The paper combines a formal graph-theoretic theorem, ONNX operator semantics, and empirical NAS benchmarking; readers need familiarity with neural network graphs, channel pruning, and edge deployment constraints.

Scope: One-sentence scope: the paper introduces H3DNAS, a compression framework that prunes, mutates, and searches 3D point cloud models directly on serialized onnx.ModelProto graphs, and validates it on PointNet, PointNet++, and PointMLP against the ModelNet40 benchmark and an NVIDIA Jetson Orin Nano 8GB budget.

What This Paper Is About

Vendors and model repositories often ship models as compiled ONNX binaries, but nearly all existing compression and NAS methods assume you have the original PyTorch or TensorFlow source code, live module objects, and gradients — so those binaries cannot be compressed. H3DNAS targets this gap by treating the ONNX graph itself as the object to read, mutate, prune, and rank, with no architecture class definition, no training framework API, and no backward pass required during search. The goal is to deliver compact, edge-feasible 3D point cloud models that keep baseline accuracy while meeting hard deployment budgets.

Key Contributions

1. Channel Dependency Graph (CDG) and the ρ_f theorem. The CDG classifies ONNX operators into four classes — Channel-Generating (CG), Channel-Transparent (CT), Channel-Constraining (CC), and Channel-Terminating (CX) — and Theorem 1 establishes that the free parameter fraction ρ_f is a topological invariant of the graph, computable in O(|V|+|E|) time, forming a provable ceiling for channel pruning on the base graph.

2. Two-stage hierarchical search. Stage 1 prunes candidates via L1-importance channel selection with BatchNorm alignment and ranks them by output fidelity (cosine similarity between base and pruned logits on random inputs), a zero-shot, label-free proxy; Stage 2 applies GhostConv structural mutations to Pareto-optimal Stage 1 candidates.

3. First source-code-free compression pipeline for 3D point cloud models. The entire pipeline runs via ONNX graph surgery, with fine-tuning performed by reconstructing trainable modules from the pruned ONNX using onnx2torch; no original architecture definition is used.

4. Hardware-agnostic constraint integration. A HardwareConstraints module encodes hard limits on parameters, FLOPs, model size, and latency inside the search loop, with built-in presets for the NVIDIA Jetson Orin Nano 8GB.

Main Findings

• Parameter and speed results on ModelNet40. PointNet: 65.5% parameter reduction, 1.99× speedup, −0.04 pp accuracy (90.32% → 90.28%), 3.46M → 1.19M parameters, 63.4% FLOP reduction, 13.32MB → 4.65MB, 11.98ms → 6.02ms. PointNet++ SSG: 43.2% reduction, 1.29× speedup, +0.08 pp (91.90% → 91.98%), 1.47M → 0.83M, 43.1% FLOP reduction, 5.70MB → 3.27MB, 37.14ms → 28.86ms. PointMLP: 49.1% reduction, 1.67× speedup, −0.28 pp (93.40% → 93.11%), 13.20M → 6.72M, 48.8% FLOP reduction, 50.86MB → 26.07MB, 347.0ms → 207.8ms.

• ρ_f is verified as a topological invariant. The Free/Constrained node split is identical between base and H3DNAS ONNX variants (12/6 for PointNet, 9/3 for PointNet++, 19/21 for PointMLP, 6/17 for PCT, 15/75 for PTv3 in Table 3), and ρ_f shifts only marginally (Δρ_f ≈ 0.03–0.05) when GhostConv mutations introduce new channel-in couplings.

• Pre-search feasibility prediction. CDG analysis runs in under one second from graph topology alone (no weights, no data, no execution). Reported ρ_f values: PN 58.13%, PN++ 61.43%, PMLP 47.25%, PCT 12.34%, PTv3 13.97%. The paper also reports ρ_f = 45.7% for MobileNetV2 with only 2 free nodes of 53, where the CDG correctly predicts channel pruning alone cannot reach the Jetson budget.

• Ceiling gaps vary by architecture. Achieved reduction versus ρ_f: PN 65.5% versus 58.13% (attributed to width scaling creating a modified graph G′), PN++ 43.2% versus 61.43% (18.2 pp gap), PMLP 49.1% versus 47.25%, PCT 6.7% versus 12.34% (5.64 pp), PTv3 11.1% versus 13.97% (2.87 pp).

• Jetson Orin Nano 8GB constraint satisfaction. The base PointNet violates three of four constraints (3,451,859 parameters versus a 2M budget; 870M FLOPs versus 500M; 13.3 MB and 12.7 ms within budget). H3DNAS yields 1,463,271 parameters (+26.8% headroom), 386M FLOPs (+22.8%), 5.63 MB (+88.7%), and 7.4 ms P50 latency (+85.2%), with accuracy moving −0.04 pp to 90.28%.

• Stage 2 GhostConv is architecture-dependent. PointNet benefits: at identical 32.3% compression, Stage 2 reaches 1.80× versus Stage 1's 1.46× (a +0.34× gain) for −0.08 pp accuracy (89.99% versus 90.07%). PointNet++ gains marginally (2.64× versus 2.67×, both −0.12 pp). PointMLP is hurt by Stage 2 (−0.57 pp and 1.20× versus −0.28 pp and 1.24× at 26.8%), attributed to its 21 of 40 nodes constrained by R2 Add constraints.

• Comparison against prior methods. PointNet++ matches CP³'s 43% compression ratio from the ONNX file alone; CP³+HRank reports +0.15 pp at 43%, CP³+ResRep +0.47 pp at 44%. PointMLP's 93.11% at −0.28 pp is compared against T3DNet (92.45% → ~91.0%, −1.45 pp, 98%) and HLS4PC (93.60% → 91.69%, −1.91 pp), which the paper describes as knowledge distillation and input-point reduction rather than weight compression.

• Compression ceiling taxonomy. Simple CNNs with no residual connections are nearly fully compressible (ρ_f ≈ 99%); residual architectures such as ResNet50 and PointNet have moderate freedom (28–58%); mobile-optimized architectures with depthwise convolutions or SE attention are severely constrained (4–12%).

• Internal reporting notes. The paper reports PointNet's ρ_f as 58.13% in Tables 1–3 but states 58.1% and 57.6% in the practical-significance discussion and 57.96% with "11 free nodes" in Section 4.4; for PTv3 the Free/Constrained split appears as 28/62 in Table 1 and 15/75 in Table 3.

Methodology in Plain English

The researchers start from a compiled ONNX file and first run shape inference so every tensor edge has a known dimension. They then build a Channel Dependency Graph over the Conv and Gemm nodes, connecting two nodes whenever one's output channel count must equal the other's input channel count for the graph to stay valid. This lets them sort every node into either "freely prunable" or "locked" by one of five constraint rules they derived exhaustively from the ONNX operator specification: R1 static shape terminators, R2 dynamic tensor equality, R3 grouped convolution immutability, R4 semantic output fixity, and R5 learned normalisation locks. Because this classification depends only on operator types and connectivity — not weight values — they prove that the share of parameters living in free nodes (ρ_f) is fixed by topology, giving a ceiling on how much channel pruning can ever achieve.

Search then proceeds in two stages. Stage 1 samples width multipliers in [0.5–1.0] and prune ratios in [0.05–0.50] using an evolutionary strategy (seed = 105), cuts the lowest-L1-norm output channels on free nodes, propagates the surviving channel indices to downstream operators, and realigns BatchNorm statistics. Instead of training candidates, it screens them with a cheap proxy: feed 32 random inputs to both the base and pruned models and measure cosine similarity of the logits ("output fidelity"); only the top 15 go on to labeled accuracy evaluation with ONNX Runtime. Stage 2 takes the Pareto-optimal Stage 1 candidates and replaces eligible convolutions (groups = 1, C_out ≥ 16) with a two-branch GhostConv equivalent — a primary conv producing half the channels plus a cheap depthwise branch — initialized near identity so the output distribution is preserved at zero shot. All candidates are merged into one Pareto frontier and filtered against the hardware budget. Fine-tuning uses ONNX-to-PyTorch reconstruction with Adam at learning rate 5×10⁻⁴, weight decay 10⁻⁴, 15 epochs, and cosine annealing.

Why This Matters

Impact on research. The paper claims the first NAS framework applied to PointNet, PointNet++, and PointMLP from ONNX alone, and the first integration of GhostConv architectural search operating natively on onnx.ModelProto binaries. The ρ_f theorem offers a provable, O(|V|+|E|) compression ceiling that prior work does not have, and it reframes compression feasibility as something you can compute before running any experiment — including a principled recommendation to switch to quantization when ρ_f is low.

Real-world applications:

• Compressing vendor-supplied or cross-framework ONNX models when the original training repository is lost, proprietary, or incompatible.
• Deploying real-time 3D perception on edge robots and drones where the Jetson Orin Nano-class budget (≤4B FLOPs, ≤20M parameters, ≤50MB, ≤50ms in this paper's setup) is the operating constraint.
• AutoML and MLOps tooling that needs to ingest arbitrary compiled models and produce compression candidates without rebuilding training pipelines.
• Post-training quantization workflows, since the paper explicitly decouples structural compression from quantization and leaves quantization to ONNX Runtime.

Industry relevance. The paper argues that every prior compression tool is tied to a specific framework's module APIs, while vendor distribution increasingly means ONNX binaries. A framework-agnostic method that also returns a full Pareto frontier from a single search run fits deployment pipelines where engineers must hit fixed hardware budgets without retraining from scratch.

Future Directions

• On-device rather than CPU-proxied latency. The paper's stated limitation is that latency is measured using ONNX Runtime CPU execution (batch = 1, 100 timed runs, P50 median) rather than on the Jetson GPU directly; stronger hardware claims would require on-device profiling.
• Level 2 structural mutations. H3DNAS-Full currently supports Level 1 mutations (activation and pooling substitution at the onnx.ModelProto level); Level 2 structural mutations such as depthwise decomposition require weight re-initialization and are explicitly left for future work.
• Broader operator coverage for fine-tuning. Fine-tuning via onnx2torch succeeded for all tested models but the paper notes it may require manual intervention for operators outside onnx2torch's supported set.
• Extending beyond channel pruning. Gradient-based DARTS-style architecture optimization requires differentiable parameters and is declared out of scope; the paper also leaves correlation of its latency results with other edge devices to future work.

Target Audience

This paper is most useful to deployment and edge-ML engineers working with compiled ONNX models; NAS and structured-pruning researchers interested in training-free quality proxies and formal compression bounds; and practitioners applying 3D point cloud or LiDAR perception models on constrained hardware. Readers wanting the full regime analysis, 2D classification results, and the executable operator classification tables are directed by the paper to its Supplementary Document. The source code is listed as available at https://github.com/ClarityLab-Org/h3dnas.

Authors’ abstract

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}.