Quantizing Fault Detectors When No Fault Data Exists

Machine-fault detectors run on small embedded devices bolted to the machines they watch, so they eventually have to be compressed. The standard compression step is quantization: storing weights and intermediate activations as 8-, 4- or 2-bit integers instead of 32-bit floats. It works by measuring the range of values each layer produces on a small "calibration" set and fitting a coarse integer grid to that range. In fault diagnosis this creates a hidden problem. The data that exists at deployment is almost entirely healthy-machine vibration, because machines are built and maintained so that they do not fail. A quantizer calibrated on healthy signals fits its grids to healthy activations. The large, impulsive activations that bearing cracks produce can then be clipped or crushed into one bin. Overall accuracy, which is dominated by healthy samples, may barely move while recall on rare fault classes drops sharply. Nothing in the standard pipeline would flag this.

We propose to measure this failure directly and to test a cheap fix. The fix is to calibrate with synthetic fault surrogates: healthy recordings with injected impulse trains at the bearing's known defect frequencies. These signals are not realistic enough to train a classifier. The bet is that they are realistic enough to show the quantizer which activation ranges fault signals occupy, because calibration only needs the right value ranges, not faithful samples. If the hypothesis holds, practitioners get a recipe for compressing few-shot fault models to 4 bits and below without silently losing the faults they exist to catch. If it fails, the field learns that low-bit fault detectors need real fault data even for calibration.

Core Claim

Our central claim is that quantization damage in data-scarce fault diagnosis concentrates on fault classes rather than spreading evenly across classes. The damage comes mainly from activation ranges fitted to healthy-only calibration data. Calibration sets enriched with physics-cheap fault surrogates should recover most of the fault recall that real-fault calibration would give, at 4 bits and possibly 3 bits for weights and activations.

The research file contains no prior work quantizing fault-diagnosis models.

  • UniFault pretrains a 6.4M-parameter vibration transformer on 6.9 million bearing samples and ships an 823K-parameter "Lite" version for edge devices. It reaches that size only by shrinking the architecture, never by quantizing.
  • MIX-MPDKD distills a meta-learned teacher into a 13.51K-parameter student and stops at floating point.

The quantization side that comes closest is data-free quantization.

  • AdpQ finds outlier weights by statistical shrinkage applied to the weight tensor alone.
  • NSDS assigns per-layer bit-widths from weight kurtosis and singular-value spectra.
  • AlphaQ allocates bits across mixture-of-experts experts from heavy-tailed weight spectra.

These three motivate the proposal because they confirm that calibration data is a real liability. They also constrain it, because they handle only the weights and evaluate only on language models. Activation ranges, which matter most for impulsive vibration signals, cannot be set from weights at all. That is the gap we target.

Research Program

The work has three parts.

Measuring the failure. We take few-shot fault models in floating point and quantize them across a grid of bit-widths. Weights go to 8, 4, 3 and 2 bits. Activations go to 8 and 4 bits. Calibration uses one of four sources:

  • healthy-only data;
  • the handful of real labeled fault samples used for few-shot adaptation;
  • fault surrogates;
  • no data at all, via weight-only data-free methods.

The headline quantity is not accuracy. It is the silent miss rate: the fraction of test faults the floating-point model catches that the quantized model misses. We report it alongside per-class recall and macro-F1. We also log, per layer, how much of the fault-sample activation mass falls outside the calibrated range. This tests whether clipping, rather than weight rounding, explains the losses.

Building the surrogates. We use the textbook localized-defect model of a rolling bearing. Ball-pass and spin frequencies follow from bearing geometry and shaft speed, which are documented for CWRU and PU. At those rates we inject impulse trains that excite a decaying resonance, add them to healthy segments, and sweep amplitude so the injected impulses cover a range of fault severities. Nothing is learned: there is no GAN and no diffusion model. This sidesteps the instability and cost that DAC-FCF reports for its conditional GAN.

The memory-matched question. At a fixed footprint of about 3.2 MB, should one deploy UniFault-Lite in 32-bit floats or UniFault-Base at 4 bits? This tests in the vibration domain the result from 1-Bit Wonder: for language models, larger low-bit models beat smaller full-precision ones at equal memory. We treat that as a hypothesis, not a given. The answer may flip once calibration is healthy-only, which is exactly the interaction we want to expose.

Baselines

Naive baseline. The floating-point model itself sets the ceiling. Below it is the naive practice: per-channel min-max quantization calibrated on healthy data only, which is what a practitioner would do by default. Beating it means a lower silent miss rate at the same bit-width.

Real-fault calibration. This is the strongest data-driven competitor. It uses the 20-per-class (CWRU) or 100-sample (IMS) labeled fault sets already consumed by few-shot adaptation. The calibration algorithm is identical across sources: the same range estimator, the same rounding of weights by second-order error estimates, and the same number of calibration batches. Only the source of the calibration signals changes. Surrogates "beat" this baseline if they come within one point of its fault macro-F1 while using zero real faults. A tie counts as a positive result, because surrogates also work for fault classes never observed.

Data-free baselines. These are the strongest calibration-free competitors. AdpQ and NSDS are reimplemented for one-dimensional convolutions and the UniFault encoder. Activations are quantized with healthy-only ranges in this arm, since these methods supply none of their own. For language-model weights, AdpQ reports 64.23 average zero-shot score on 3-bit LLaMA-7B, against 63.77 for the calibration-based SpQR. For any quantized fault-diagnosis model, we found no reported result on Lacuna, so all quantized numbers here are new.

Floating-point reference points. These are the numbers our compressed models are measured against.

  • UniFault-Base reports 98.1% accuracy on IMS with 100 labeled samples.
  • MIX-MPDKD reports 99.48% average accuracy on CWRU and 99.70% at 0 dB signal-to-noise ratio.

Ablation. To isolate the key ingredient, we compare four calibration signals of matched energy:

  • impulses at the true defect frequencies;
  • impulses at random frequencies;
  • generic heavy-tailed noise;
  • Gaussian noise.

If random impulses work as well as physics-placed ones, the claim narrows to "calibration needs heavy-tailed range coverage." We would report that honestly. It would still be a useful and simpler recipe.

Why not just…?

Why not just use INT8, which microcontrollers run natively? INT8 is likely close to lossless for these models, and we expect our 8-bit runs to confirm that. The problem appears only below 8 bits. It matters because memory-matched deployment of the larger foundation model requires 4 bits. The cliff behavior documented for language models below 3 bits (QuIP reports standard rounding collapsing to 123.91 perplexity at 2 bits) has never been charted for vibration models. If 4-bit healthy-only calibration turns out harmless, that is itself a publishable negative result, and our grid would show it.

Why not just calibrate on the few real faults you already have? This is the most serious threat, and it is a first-class baseline. It fails in two places that matter for deployment. The first is unseen fault types, which the LiU-ICE benchmark (six solutions; A fault diagnosis benchmark of technical systems with incomplete data — six solutions) shows are where diagnosers already struggle. The second is per-site quantization, where only local healthy data is on hand. We test both by holding out entire fault classes from calibration. Surrogates win only if they protect the held-out classes better.

Why not just quantize data-free with AdpQ or NSDS? These methods address weights only. Impulsive fault signals threaten activations, whose ranges no weight statistic can set. The data-free arm will show whether that matters in practice. If data-free weights combined with healthy-only activation ranges match surrogate calibration, our proposal reduces to an activation-only fix.

Why not just ship UniFault-Lite unquantized? Our memory-matched comparison answers this directly. Neither outcome is assumed.

Proposed Experiments

Models and datasets. We use UniFault-Base and UniFault-Lite, MIXCNN, and a WDCNN-style wide-kernel network. Data come from three sources:

  • CWRU under the 20-samples-per-class protocol of DAC-FCF;
  • IMS under UniFault's 100-sample protocol;
  • Paderborn, whose artificial versus real accelerated-life damage gives a natural sim-to-real split: artificial damage serves as an extra calibration source, real damage as the test.

Noise robustness is measured by adding white noise down to 0 dB, following MIX-MPDKD's protocol. A non-bearing check on CH-BatteryGen tests whether the clipping effect generalizes beyond vibration. There the surrogate is an equivalent-circuit fault injection, and the reference is 0.9280 fault-classification F1.

Decisive checks. Four results decide the outcome.

  1. Healthy-only calibration must produce a fault-class recall drop markedly larger than its overall accuracy drop at 4 bits. Otherwise the motivating effect is absent.
  2. Out-of-range activation mass on fault samples must predict that drop across layers.
  3. Surrogate calibration must close most of the gap to real-fault calibration on seen classes and beat it on held-out classes.
  4. The physics-frequency ablation must show whether placing impulses at the true defect frequencies matters.