Keeping the Reasons Intact When Binarizing Point Cloud Classifiers

When a 3D point cloud classifier is shrunk to 1-bit weights and activations so it can run on a Raspberry Pi or a robot's embedded board, the only thing anyone checks is whether accuracy survives. This proposal argues that accuracy is the wrong thing to watch. A compressed model can keep its accuracy while changing why it predicts what it does. For a black-box network that change is invisible. For a case-based network, one that classifies by saying "this part of the input looks like that part of a training example," the change is directly measurable. We propose to build a binarized case-based point cloud classifier and to measure how often compression silently swaps out the evidence the model relies on. We then show that a compression objective which preserves the model's similarity to its stored examples, rather than its output scores, keeps those reasons intact at almost no accuracy or latency cost.

The two-sentence version is this. A prototype classifier's class scores are a sparse linear readout of many prototype similarities, so ordinary distillation, which matches only the class scores, leaves most of those similarities unconstrained and lets the explanation drift during binarization. Distilling the full similarity profile of the full-precision model into a 1-bit backbone should give a point cloud model that is about as small and fast as existing binary networks and whose explanations still point to the same training parts as the uncompressed model.

Core Claim

We make three claims. First, binarizing a prototype-based point cloud network with existing 1-bit techniques preserves accuracy far better than it preserves explanation agreement, meaning the nearest-prototype evidence differs from the full-precision model on a large fraction of inputs. Second, this drift follows from structure. With $m$ prototypes and $L$ classes, logits are $z = W s(x)$, where $s(x) \in \mathbb{R}^m$ holds the input's maximum similarity to each prototype and $W$ is the sparse $L \times m$ last layer. Logit matching constrains only the projection of $s$ onto the row space of $W$, a space of dimension at most $L$, and leaves the remaining $m - L$ directions free. Third, replacing logit distillation with similarity-profile distillation closes most of the agreement gap while keeping ModelNet40 accuracy within the range of current binary point networks.

Prior Work and Where This Sits

Two works supply the compression side. BiPointNet binarizes PointNet-family models. It shows that max-pooling over many binary point features collapses their information content ("feature homogenization"). It fixes this with a learnable shift before pooling and a per-layer scale, and it reports 86.4% on ModelNet40 against 88.2% at full precision, with a 14.7× speedup on an ARM Cortex-A72. POEM pushes 1-bit PointNet to 90.2% on ModelNet40 by fitting weights to a two-mode mixture with expectation-maximization. We reuse their binarization machinery as our backbone. Both are opaque, and both judge success by accuracy alone. BiPointNet's homogenization result also constrains our design: prototypes attached after a global max-pool over binary features would collapse. We therefore attach prototypes to local neighborhood features before global pooling.

This Looks Like That supplies the interpretable mechanism. ProtoPNet learns prototype vectors and "projects" each one onto a real training patch, so every prototype can be viewed. It classifies through a sparse linear layer over prototype similarities and matches black-box accuracy on CUB-200 (76.1% versus 74.6% for VGG-16). It works only on full-precision 2D images and is known to latch onto background patches. Real point cloud scans, such as ScanObjectNN's perturbed-background split, are a natural place to test that weakness. Concept Bottleneck Models motivate the value of test-time intervention: correcting two concepts on OAI cut task error from over 0.4 to about 0.3. We use prototypes rather than concepts because 3D datasets lack concept labels.

Three works already sit between pairs of our directions, and each lacks a different piece. PointMask explains point cloud classifiers by learning which input points to drop, and it resists injected shortcut points. However, it keeps full-precision weights and gives saliency rather than case-based evidence. PCQ quantizes point features onto text embeddings from a vision-language model, reaching 94.1% on ModelNet40. Its "quantization" is a semantic dictionary rather than low-bit arithmetic, and it needs a heavy text encoder plus cross-attention that edge hardware cannot carry. Sum-of-Parts shows faithful group attributions survive heavy input sparsity, but it uses multiple passes through large 2D backbones.

On the compression-recovery side, RestoreLCC and Compress, Then Prompt repair compressed language models by targeting what compression destroyed. RestoreLCC in particular finds that the useful signal sits in minor directions of the activation gap, not the dominant ones. That finding is the nearest analogue to our argument that matching the dominant output directions, the logits, misses what matters. Our distillation target differs because it is defined by the interpretable layer rather than by an SVD of activations. None of these works asks whether a compressed model's explanations agree with its uncompressed parent.

Research Program

The model is a point prototype network. A set-abstraction backbone groups each point's neighbors and produces local part features. We use PointNet++-style grouping and an ASSANet-style separable variant, which runs the heavy layers only on sampled center points. A prototype layer holds $m$ vectors, ten per class on ModelNet40. For each input it computes ProtoPNet's log-ratio similarity between every local part feature and every prototype, max-pools over parts to get $s(x)$, and feeds $s(x)$ to a sparse linear classifier. After training, each prototype is projected onto its nearest real training neighborhood, so the explanation for any prediction is a short list of 3D parts from training objects with the matched region highlighted on the input.

Compression proceeds in three steps. The backbone is binarized with BiPointNet's shift-and-scale recipe, and separately with POEM's bimodal weights. The prototype vectors and last layer stay at 8 bits. They are a few thousand numbers, and the ablation tests whether they can be binarized too. Similarities are computed on scale-recovered features, so distances are not reduced to the coarse integer steps that pure Hamming distance would give.

The student is trained against the full-precision prototype network as teacher, which fixes the student's prototypes to the teacher's projected parts:

$$\mathcal{L} = \mathcal{L}_{\text{CE}} + \lambda\, \mathrm{KL}\big(\sigma(s_T(x)/\tau)\,\|\,\sigma(s_S(x)/\tau)\big),$$

Here $s_T$ and $s_S$ are the teacher and student similarity profiles over all $m$ prototypes, $\sigma$ is the softmax, $\tau$ is a temperature, and $\lambda$ weights the term. Because $m \gg L$, this constrains directions that logit distillation cannot see.

The analysis has three parts. The first measures explanation drift across compression levels (FP32, INT8, INT4, 1-bit) and training objectives. The second relates drift to where it happens, testing whether drift concentrates on sparse or thin parts, as LiDAR-PTQ found that calibration clips sparse distant objects in detectors. The third tests whether the binarized model's explanations are still usable: whether prototype deletion and intervention behave as they do at full precision.

Baselines

The naive reference points are full-precision PointNet and BiPointNet as an opaque 1-bit model. BiPointNet reports 86.4% on ModelNet40 against 88.2% at full precision (BiPointNet). They anchor accuracy and storage but provide no explanations. The strongest compressed accuracy baseline is POEM's 1-bit PointNet at 90.2% on ModelNet40, with a full-precision baseline of 89.3% (POEM). We rerun both in our pipeline with the same point sampling, augmentation, and epoch budget, and we report our reproduced numbers alongside the published ones.

For the interpretable reference, no reported result was found on Lacuna for a prototype-based point cloud classifier, so our full-precision point prototype network is itself a new baseline. We train it to a black-box-matched accuracy before any compression, mirroring ProtoPNet's claim that prototypes need not cost accuracy.

The strongest competitor on the actual question is the same binarized prototype network trained with standard logit distillation from the same teacher. It has identical architecture, data, teacher, epochs, and a hyperparameter search of equal size over its temperature and weight. A second competitor trains with cross-entropy only. A third applies post-training INT8 quantization to the full-precision prototype network with sparsity-aware max-min calibration in the style of LiDAR-PTQ.

Beating the strongest competitor means two things together: a top-1 prototype agreement with the teacher at least 15 points higher than logit distillation, and accuracy within one point of it. The size of the agreement gap is set in advance as the threshold for a meaningful effect.

Two ablations isolate the key ingredient. The first swaps similarity-profile distillation for logit distillation with everything else fixed. The second varies prototype precision (8-bit versus 1-bit Hamming similarity) and prototype placement (local parts versus after global pooling). The placement ablation tests whether BiPointNet's homogenization result causes prototypes to collapse into identical codes.

Why not just…?

Why not just use logit distillation, which already transfers the teacher's behavior? This is the main threat. If logit distillation already keeps prototype agreement high, our method adds nothing and the paper becomes a measurement study. The rank argument says logits pin down at most $L$ of $m$ similarity directions, but the backbone could still preserve the rest by accident. The head-to-head comparison settles this directly. We also report the drift-free bound, meaning agreement between two full-precision models trained from different seeds, so that we do not demand more stability than full precision itself provides.

Why not just quantize a full-precision prototype network to INT8 after training? At INT8 this may simply work. LiDAR-PTQ reports only a 0.2 mAPH drop on Waymo (60.32 to 60.12) with a 3× speedup on Jetson Orin, though for detectors, not prototype models. We include INT8 in the compression sweep and expect little drift there. The proposal targets the 1-bit regime, where BiPointNet's 7.1% vanilla-binarization result shows that naive approaches break. If INT4 also shows no drift, we will report that the problem begins only below 4 bits.

Why not just binarize a black-box model and explain it post hoc with saliency or PointMask-style masking? Post-hoc maps describe correlations with the output rather than the computation, and they cannot be intervened on. PointMask is itself a trained full-precision module, not a post-hoc tool for a binary network. We test this alternative empirically with the same deletion test: removing the top-attributed region should drop confidence more for prototype evidence than for saliency on BiPointNet.

Why not just use text-grounded codebooks as in PCQ? PCQ's accuracy is higher, 94.1% on ModelNet40. However, its interpretability depends on a vision-language encoder and cross-attention that do not fit our hardware target. We report it as an accuracy ceiling, not as a deployable competitor.

Proposed Experiments

ModelNet40 is the primary benchmark, because published full-precision and 1-bit numbers exist there. ScanObjectNN's perturbed-background split tests whether binarization pushes prototypes toward background clutter, measured as the fraction of matched points on background. PointMask's shortcut protocol injects 256 biased points during training and removes them at test time; PointMask reports 76% under this protocol. We use it to ask whether drifted explanations coincide with shortcut reliance.

Metrics are as follows. Accuracy is the standard measure. Top-1 and top-5 prototype agreement with the teacher capture explanation drift. Deletion faithfulness is the confidence drop when the input neighborhood matched to the top prototype is removed, compared against removing a random neighborhood of equal size. Intervention gain is the accuracy recovered when a user disables background-matching prototypes on ScanObjectNN. Efficiency is reported as model storage and measured latency on a Raspberry Pi 4 with an ARM Cortex-A72, matching BiPointNet's device, with the prototype layer's share of runtime reported separately.

The decisive checks run in order. First, logit-distilled 1-bit models must show substantial drift at near-teacher accuracy; if they do not, the motivation fails and we say so. Second, similarity-profile distillation must close most of that gap without costing more than a point of accuracy relative to POEM-style backbones. Third, deletion faithfulness and intervention gain must stay close to full-precision levels. Fourth, the prototype layer must add only a small fraction of the latency of a 1-bit backbone on the Pi. Extending the approach to S3DIS segmentation is deferred until the classification result holds. On that benchmark, POEM's 45.8 mIoU shows how far binary networks still lag.