SNAP-UQ: Self-supervised Next-Activation Prediction for Single-Pass Uncertainty in TinyML

## Abstract

Abstract We introduce SNAP-UQ , a single-pass, label-free uncertainty method for TinyML that estimates risk from depth-wise next-activation prediction : tiny int8 heads forecast the statistics of the next layer from a compressed view of the previous one, and a lightweight monotone mapper turns the resulting surprisal into an actionable score. The design requires no temporal buffers, auxiliary exits, or repeated forward passes, and adds only a few tens of kilobytes to MCU deployments. Across vision and audio backbones, SNAP-UQ consistently reduces flash and latency relative to early-exit and deep ensembles (typically ∼ \sim 40–60% smaller and ∼ \sim 25–35% faster), with competing methods of similar accuracy often exceeding memory limits. In corrupted streams it improves accuracy-drop detection by several AUPRC points and maintains strong failure detection (AUROC ≈ \approx 0.9) in a single pass. Grounding uncertainty in layer-to-layer dynamics yields a practical, resource-efficient basis for on-device monitoring in TinyML.

## 1 Introduction

TinyML models increasingly ship on battery-powered microcontrollers (MCUs) to deliver private, low-latency perception for vision and audio (Banbury et al., 2021). Once deployed, inputs seldom match the training distribution: sensors drift, lighting and acoustics vary, and streams interleave in-distribution (ID), corrupted-in-distribution (CID), and out-of-distribution (OOD) samples (Hendrycks & Dietterich, 2019). Under such shifts, modern networks are notoriously *overconfident* (Minderer et al., 2021) even when they appear calibrated on held-out ID data (Guo et al., 2017; Ovadia et al., 2019), complicating on-device monitoring and safe fallback. Addressing this on MCUs is challenging: memory and compute budgets preclude multi-pass inference, large ensembles (Lakshminarayanan et al., 2017), or heavy feature stores.

#### This work:

We introduce SNAP-UQ (*Self-supervised Next-Activation Prediction for single-pass Uncertainty*), a label-free uncertainty mechanism tailored to MCU deployments. Instead of sampling-based uncertainty (e.g., MC Dropout (Gal & Ghahramani, 2016)) or branching with auxiliary exits, SNAP-UQ attaches *two or three tiny heads* at chosen depths. Each head predicts the next-layer activation statistics from a low-rank projection of the previous layer; the mismatch between the realized and predicted activation yields a *depth-wise surprisal* score (Sensoy et al., 2018). Aggregating these per-layer surprisals produces a single-pass uncertainty proxy that (optionally) blends with an instantaneous confidence term. The approach requires no extra forward passes, no temporal buffers, and no architectural changes to the backbone. All arithmetic is integer-friendly: the heads are quantized to int8, covariance is diagonal (with an optional low-rank correction), and exponentials are replaced by a small look-up table for $\exp(-\tfrac{1}{2}\log\sigma^{2})$ (Jacob et al., 2018).

#### Why depth-wise surprisal?

Confidence at the softmax often degrades late and can remain peaky under CID, whereas *inter-layer dynamics* shift earlier: features become atypical *relative to the network’s own transformation* even before class posteriors flatten. SNAP-UQ explicitly models this conditional evolution $a_{\ell-1}\!\mapsto\!a_{\ell}$ and scores how surprising $a_{\ell}$ is under the head’s predictive distribution. The resulting score acts as an early, label-free indicator of trouble while preserving MCU budgets. Unlike classwise Mahalanobis (Lee et al., 2018) or energy-based OOD methods (Liu et al., 2020), which compare against unconditional feature statistics or log-sum-exp energies, SNAP-UQ is *conditional-on-depth* and thus sensitive to distortions that break the mapping between layers.

#### Relation to prior work:

Post-hoc calibration improves ID confidence but generally fails under shift (Guo et al., 2017; Ovadia et al., 2019). Early-exit ensembles and TinyML variants reduce cost by reusing a backbone (Qendro et al., 2021; Ghanathe & Wilton, 2024), yet still add inference-time heads and memory bandwidth, and depend on softmax-derived signals that are brittle under CID. Sampling-based uncertainty (MC Dropout, Deep Ensembles) increases compute and flash substantially (Gal & Ghahramani, 2016; Lakshminarayanan et al., 2017). Classical OOD detectors such as ODIN/G-ODIN (Liang et al., 2018; Hsu et al., 2020) can be strong on larger backbones but transfer less reliably to ultra-compact models typical of TinyML. Beyond ensembles and stochastic sampling, several *single-pass* deterministic UQ methods have been proposed—e.g., DUQ, DDU, evidential/posterior/prior networks, and recent fixes for early-exit overconfidence—but many rely on architectural changes, specialized output layers, OOD exposure during training, or heavier heads that clash with MCU constraints (Van Amersfoort et al., 2020; Mukhoti et al., 2023; Sensoy et al., 2018; Malinin & Gales, 2018; Charpentier et al., 2020; Deng et al., 2023; Meronen et al., 2024). In contrast, SNAP-UQ occupies a different point: *single pass, no state, tiny heads*, with a score derived from the network’s own depth-wise dynamics rather than auxiliary classifiers or repeated sampling.

#### Contributions:

SNAP-UQ introduces a self-supervised, depth-wise surprisal signal from tiny predictors attached to a few layers and trained with a lightweight auxiliary loss, yielding *single-pass* uncertainty at inference with no temporal buffers, auxiliary exits, or ensembles. The aggregate surprisal is an affine transform of a depth-wise negative log-likelihood (equivalently a conditional Mahalanobis energy) and is invariant to BN-like per-channel rescaling; we also derive robust (Student-$t$/Huber) and low-rank+diag variants (Appx. [H](https://arxiv.org/html/2508.12907v1#A8), [I](https://arxiv.org/html/2508.12907v1#A9)). We provide an MCU-ready implementation using $1{\times}1$ projectors with global average pooling, int8 heads, LUT-based scales for $\log\sigma^{2}$, and a tiny monotone mapper, adding only a few-tens of KB of flash and $\lesssim\!2\%$ extra MACs. Empirically, across MNIST, CIFAR-10, TinyImageNet, and SpeechCommands on two MCU tiers, SNAP-UQ improves accuracy-drop detection under CID, is competitive or better on ID$\checkmark$ — ID$\times$ and ID$\checkmark$ — OOD failure detection, and strengthens ID calibration—while fitting on the *Small-MCU* where heavier baselines are out-of-memory.

#### Overview:

Section [2](https://arxiv.org/html/2508.12907v1#S2) details the method and training objective; Section [3](https://arxiv.org/html/2508.12907v1#S3) outlines datasets, MCU setup, and baselines; Section [4](https://arxiv.org/html/2508.12907v1#S4) reports deployability, monitoring, failure detection, and calibration; Appendices [Appendix](https://arxiv.org/html/2508.12907v1#Ax1) provide proofs, low-rank derivations, calibration alternatives, and implementation notes for integer inference.

## 2 SNAP-UQ Explained

We consider the same depth-$D$ backbone that maps an input $x$ to activations $\{a_{\ell}\}_{\ell=0}^{D}$ with $a_{0}=x$, final features $f(x)=a_{D}$, and class posteriors $p_{\phi}(y\mid x)=\mathrm{softmax}(g(a_{D}))\in\Delta^{L-1}$. Let $\hat{y}=\arg\max_{\ell}p_{\phi}(y=\ell\mid x)$, maximum confidence $C_{\phi}(x)=\max_{\ell}p_{\phi}(y=\ell\mid x)$, and probability margin $m^{\mathrm{mg}}(x)=p^{(1)}_{\phi}(x)-p^{(2)}_{\phi}(x)$ where $p^{(1)}_{\phi}(x)\geq p^{(2)}_{\phi}(x)\geq\cdots$ are sorted class probabilities. In contrast to temporal methods, SNAP-UQ builds a label-free *depth-wise* uncertainty signal in a single forward pass by predicting each tapped layer’s next activation from the previous one and measuring the surprisal (negative log-likelihood) of the realized activation under that conditional model. No auxiliary exits, multiple passes, or temporal buffers are introduced.

Figure: Figure 1: SNAP-UQ micro-view. A small set of tapped layers $\mathcal{S}$ attaches tiny predictors $g_{\ell}$ that forecast the next activation statistics $(\mu_{\ell},\sigma_{\ell}^{2})$ from a low-rank projection $P_{\ell}a_{\ell-1}$. The per-layer surprisal $e_{\ell}$ is aggregated into a single-pass uncertainty proxy $S(x)$ and mapped by a light logistic head; optionally blend with instantaneous confidence/margin for better separability. Dashed blocks are training-only.
Refer to caption: SNAPUQ1.jpg

#### Design goals and assumptions.

SNAP-UQ is built for milliwatt-scale devices with a single forward pass, constant memory, and integer inference. We assume: (i) the backbone is fixed at deployment; (ii) per-layer activations $a_{\ell}$ are available in the course of the standard pass; (iii) the device can perform a handful of extra linear ops per tapped layer $\ell\in\mathcal{S}$ and elementwise arithmetic; (iv) no labels or long histories are available online.

### 2.1 Depth-wise next-activation model

Fix taps $\mathcal{S}\subseteq\{2,\dots,D\}$ (two or three layers suffice in practice). For each $\ell\in\mathcal{S}$ we compress the previous activation,

$$ $z_{\ell}=P_{\ell}a_{\ell-1}\in\mathbb{R}^{r_{\ell}},\qquad r_{\ell}\ll d_{\ell-1}\equiv\mathrm{dim}(a_{\ell-1}),$ (1) $$

where $P_{\ell}$ is either a $1{\times}1$ pointwise projection with optional global average pooling (conv backbones) or a skinny linear layer (MLPs). The predictor $g_{\ell}$ outputs diagonal-Gaussian parameters

$$ $(\mu_{\ell},\log\sigma_{\ell}^{2})=g_{\ell}(z_{\ell}),\qquad\mu_{\ell},\sigma_{\ell}\in\mathbb{R}^{d_{\ell}},$ (2) $$

which define a conditional density $p_{\theta}(a_{\ell}\mid a_{\ell-1})=\mathcal{N}\!\big{(}\mu_{\ell},\,\mathrm{diag}(\sigma_{\ell}^{2})\big{)}$. We also consider a low-rank-plus-diagonal covariance for higher fidelity at nearly the same cost:

$$ $\Sigma_{\ell}=\mathrm{diag}(\sigma_{\ell}^{2})+B_{\ell}B_{\ell}^{\top},\quad B_{\ell}\in\mathbb{R}^{d_{\ell}\times k_{\ell}},\ k_{\ell}\ll d_{\ell},$ (3) $$

with log-determinant and quadratic form computed by Woodbury identities; see Appx [I](https://arxiv.org/html/2508.12907v1#A9).

### 2.2 Training objective and regularization

SNAP-UQ augments the classifier training with a label-free auxiliary loss. Over minibatch $\mathcal{B}$,

$$ $\displaystyle\mathcal{L}_{\mathrm{SS}}$ $\displaystyle=\frac{1}{|\mathcal{B}|}\sum_{x\in\mathcal{B}}\sum_{\ell\in\mathcal{S}}\underbrace{\frac{1}{2}\!\left[\big{\|}(a_{\ell}-\mu_{\ell})\odot\sigma_{\ell}^{-1}\big{\|}_{2}^{2}+\mathbf{1}^{\top}\log\sigma_{\ell}^{2}\right]}_{\text{NLL for diagonal }\Sigma_{\ell}},$ (4) $\displaystyle\mathcal{L}$ $\displaystyle=\mathcal{L}_{\mathrm{clf}}+\lambda_{\mathrm{SS}}\,\mathcal{L}_{\mathrm{SS}}+\lambda_{\mathrm{reg}}\mathcal{R},$ (5) $$

where $\lambda_{\mathrm{SS}}$ is small ($10^{-3}\!\sim\!10^{-2}$). We use regularizers: (i) *variance floor* $\sigma_{\ell}^{2}\leftarrow\mathrm{softplus}(\xi_{\ell})+\epsilon^{2}$ to prevent collapse; (ii) *scale control* $\mathcal{R}_{\mathrm{var}}=\sum_{\ell}\|\log\sigma_{\ell}^{2}\|_{1}$; (iii) optional *predictor weight decay*; (iv) *detach option*: stop-grad on $a_{\ell}$ inside $\mathcal{L}_{\mathrm{SS}}$ if the backbone’s optimization is sensitive (we ablate this in Appx [N](https://arxiv.org/html/2508.12907v1#A14)).

#### Distributional variants.

Diagonal Gaussian is integer-friendly and fast. Two robust alternatives are drop-in:

$$ Student- $t$ : $\displaystyle e_{\ell}^{(t)}=\sum_{i}\frac{\nu_{\ell}+1}{2}\log\!\Big{(}1+\tfrac{(a_{\ell,i}-\mu_{\ell,i})^{2}}{\nu_{\ell}\sigma_{\ell,i}^{2}}\Big{)}+\tfrac{1}{2}\log\sigma_{\ell,i}^{2},$ (6) Huberized: $\displaystyle e_{\ell}^{(H)}=\sum_{i}\rho_{\delta}\!\big{(}(a_{\ell,i}-\mu_{\ell,i})/\sigma_{\ell,i}\big{)}+\tfrac{1}{2}\log\sigma_{\ell,i}^{2},$ (7) $$

where $\rho_{\delta}$ is Huber’s loss. We report both as robustness checks.

### 2.3 Single-pass surprisal and mapping

At test time, the standard forward pass yields $\{a_{\ell}\}$. Each $g_{\ell}$ produces $(\mu_{\ell},\sigma_{\ell}^{2})$ from $z_{\ell}$, and we compute

$$ $e_{\ell}(x)=\big{\|}(a_{\ell}-\mu_{\ell})\odot\sigma_{\ell}^{-1}\big{\|}_{2}^{2},\qquad\bar{e}_{\ell}(x)=\tfrac{1}{d_{\ell}}e_{\ell}(x).$ (8) $$

The SNAP score aggregates across taps:

$$ $S(x)=\sum_{\ell\in\mathcal{S}}w_{\ell}\,\bar{e}_{\ell}(x),\qquad w_{\ell}\geq 0,\ \sum_{\ell}w_{\ell}=1.$ (9) $$

We convert $S(x)$ into a decision-oriented uncertainty by a tiny logistic map (Platt, 1999) and an instantaneous confidence proxy:

$$ $\displaystyle m(x)$ $\displaystyle=\alpha\big{(}1-C_{\phi}(x)\big{)}+(1-\alpha)\big{(}1-m^{\mathrm{mg}}(x)\big{)},\quad\alpha\in[0,1],$ (10) $\displaystyle U(x)$ $\displaystyle=\sigma\!\big{(}\beta_{0}+\beta_{1}S(x)+\beta_{2}m(x)\big{)},$ (11) $$

with $(\beta_{0},\beta_{1},\beta_{2})$ fitted once offline on a small labeled development mix (ID + CID/OOD). Setting $\beta_{2}{=}0$ yields a purely label-free mapping.

#### Calibration and decision rules.

We use either: (i) a fixed threshold $U(x)\geq\tau$; (ii) *risk–coverage* targeting a desired selective risk by scanning $\tau$ on the dev set; or (iii) a budgeted controller that caps long-run abstention rate at $b$ by selecting the largest $\tau$ s.t. $\mathbb{E}[\mathbb{I}[U(x)\geq\tau]]\leq b$ on the dev distribution. When budgets are tight, we prefer isotonic regression (Zadrozny & Elkan, 2002) over logistic for a nonparametric monotone mapping from $S(x)$ (or $(S,m)$) to error probability; see Appx [J](https://arxiv.org/html/2508.12907v1#A10). All calibrations are offline and do not require online labels.

### 2.4 Algorithms

Training attaches tiny per-layer predictors and optimizes a self-supervised surprisal loss, then fits a monotone map from aggregated surprisal to error probability (Alg. [1](https://arxiv.org/html/2508.12907v1#alg1)).
At inference, a single pass computes per-tap standardized errors, aggregates them into $S(x)$, maps to $U(x)$, and thresholds—without extra passes, buffers, or online labels (Alg. [2](https://arxiv.org/html/2508.12907v1#alg2)).

Figure: Algorithm 1 SNAP-UQ training (offline, label-free auxiliary)

Figure: Algorithm 2 SNAP-UQ inference (single pass, state-free)

### 2.5 Complexity, footprint, and MCU implementation

Let $d_{\ell}=\mathrm{dim}(a_{\ell})$ and $r_{\ell}=\mathrm{dim}(z_{\ell})$. For linear $g_{\ell}$ with two heads ($\mu$ and $\log\sigma^{2}$), parameter count is

$$ $\#\theta_{\ell}\approx 2\,d_{\ell}r_{\ell}+2d_{\ell}\quad(\text{biases included}),\qquad\text{FLOPs}_{\ell}=O(d_{\ell}r_{\ell}).$ (12) $$

With $|\mathcal{S}|=2$ taps, $r_{\ell}\!\in\![32,128]$, $d_{\ell}\!\in\![128,512]$, the extra FLOPs are typically $<2\%$ of tiny backbones (DS-CNN/ResNet-8) and the flash footprint is a few tens of KB at 8-bit weights. Runtime memory stores $\{P_{\ell},W_{\mu,\ell},W_{\sigma,\ell}\}$ and per-channel scales; there is no $O(W)$ temporal buffer.

#### Integer-friendly arithmetic.

We store $P_{\ell},W_{\mu,\ell},W_{\sigma,\ell}$ as int8 with per-tensor scales; compute $z_{\ell}$ and heads in int8$\to$int16$\to$int32 accumulators; dequantize once to float16 (or int8 with LUT) for the standardized error. To avoid $\exp$, we keep $\log\sigma_{\ell}^{2}$ and use $\exp(-\tfrac{1}{2}\log\sigma_{\ell}^{2})$ implemented as a 256-entry LUT (per-channel or shared). We clamp $\log\sigma_{\ell}^{2}\in[\log\sigma_{\min}^{2},\log\sigma_{\max}^{2}]$ for numerical stability and apply a small $\epsilon$ floor inside equation [8](https://arxiv.org/html/2508.12907v1#S2.E8).

#### Choosing taps and ranks.

Heuristics: pick (i) the end of a mid block (captures texture/edges) and (ii) the penultimate block (class-specific patterns). Set $r_{\ell}$ so $\text{FLOPs}_{\ell}$ is $\leq 1\%$ of the backbone each; tune $w_{\ell}$ on dev data or set $w_{\ell}\propto 1/\mathrm{Var}(\bar{e}_{\ell})$ to de-emphasize noisy taps.

### 2.6 Theory: links to likelihood and Mahalanobis

###### Proposition 2.1 (Surprisal–likelihood equivalence under diagonal-Gaussian) .

If $p_{\theta}(a_{\ell}\mid a_{\ell-1})=\mathcal{N}(\mu_{\ell},\mathrm{diag}(\sigma_{\ell}^{2}))$ as in equation [2](https://arxiv.org/html/2508.12907v1#S2.E2), then

$$ $-\log p_{\theta}(a_{\ell}\mid a_{\ell-1})=\tfrac{1}{2}\,e_{\ell}(x)+\tfrac{1}{2}\sum_{i=1}^{d_{\ell}}\log\sigma_{\ell,i}^{2}+\text{const},$ (13) $$

so $S(x)$ in equation [9](https://arxiv.org/html/2508.12907v1#S2.E9) is (up to additive/multiplicative constants and layer weighting) the depth-wise negative log-likelihood. Higher $S(x)$ implies lower conditional likelihood of the observed activations.

###### Proposition 2.2 (Relation to Mahalanobis scores) .

Let the usual Mahalanobis score use *unconditional*, classwise feature Gaussians at layer $\ell$. If the true feature dynamics are approximately linear, $a_{\ell}\approx W_{\ell}a_{\ell-1}+b_{\ell}+\varepsilon_{\ell}$ with $\varepsilon_{\ell}\sim\mathcal{N}(0,\Sigma_{\ell})$, then the conditional energy $e_{\ell}$ equals the squared Mahalanobis distance of $a_{\ell}$ to the *conditional mean* $W_{\ell}a_{\ell-1}+b_{\ell}$ under covariance $\Sigma_{\ell}$. Hence SNAP-UQ measures deviations from depth-wise *dynamics* rather than unconditional, class-averaged statistics, improving sensitivity to distribution shift that alters inter-layer transformations.

###### Proposition 2.3 (Affine invariance (scale)) .

Suppose batch-normalized activations admit per-channel affine transforms $a_{\ell}\mapsto s\odot a_{\ell}+t$. If $P_{\ell}$ and $g_{\ell}$ are trained jointly, the standardized error $e_{\ell}$ is invariant to such rescalings at optimum because $\mu_{\ell}$ and $\sigma_{\ell}$ co-adapt; formally $e_{\ell}$ is unchanged under $s$ when $\mu_{\ell}\mapsto s\odot\mu_{\ell}+t$ and $\sigma_{\ell}\mapsto|s|\odot\sigma_{\ell}$.

Proof sketches are given in Appx [H](https://arxiv.org/html/2508.12907v1#A8). Proposition [2.1](https://arxiv.org/html/2508.12907v1#S2.Thmproposition1) just unrolls the Gaussian NLL; Proposition [2.2](https://arxiv.org/html/2508.12907v1#S2.Thmproposition2) follows by conditioning and applying the Woodbury identity; Proposition [2.3](https://arxiv.org/html/2508.12907v1#S2.Thmproposition3) is immediate from reparameterization.

###### Proposition 2.1 (Surprisal–likelihood equivalence under diagonal-Gaussian) .

###### Proposition 2.2 (Relation to Mahalanobis scores) .

###### Proposition 2.3 (Affine invariance (scale)) .

### 2.7 Variants and ablations

Low-rank covariance. Using equation [3](https://arxiv.org/html/2508.12907v1#S2.E3) with $k_{\ell}\in\{4,8\}$ tightens the model with negligible extra cost (matrix–vector ops with $B_{\ell}$ only).

Mixture-of-modes. A tiny, $K$-component diagonal mixture $p(a_{\ell}\mid a_{\ell-1})=\sum_{k}\pi_{k}\mathcal{N}(\mu_{\ell,k},\mathrm{diag}(\sigma_{\ell,k}^{2}))$ with logits from $z_{\ell}$ handles multi-modality in features; compute log-sum-exp in float16.

Detachment. Detaching $a_{\ell}$ inside $\mathcal{L}_{\mathrm{SS}}$ avoids tug-of-war with $\mathcal{L}_{\mathrm{clf}}$ on small datasets; we report both.

Mapping choice. Replace logistic with isotonic regression for tighter risk–coverage when a target budget is specified; combine $(S,m)$ as two features.

Quantization-aware training (QAT). Insert fake quantization on $P_{\ell}$ and heads to reduce int8 drift in $\log\sigma^{2}$; we quantize $\log\sigma^{2}$ to 8-bit with shared scale.

#### Discussion and relation.

$S(x)$ acts as a conditional, layer-aware energy computed *along depth*, capturing feature-dynamics shifts that plain confidence/margin miss. Unlike ensembles, MC dropout, or TTA, SNAP-UQ remains single-pass and MCU-friendly; unlike temporal methods, it requires no ring buffers or streaming calibration. The approach is complementary to both and can be combined when resources allow (e.g., use $S(x)$ as one feature in a temporal controller).

## 3 Evaluation Methodology

Our objective is to test whether *depth-wise surprisal*—the core of SNAP-UQ—provides a practical, on-device uncertainty signal under TinyML constraints. We therefore measure (i) deployability on microcontrollers, (ii) usefulness for online monitoring during degradation, (iii) failure detection on ID/CID and OOD, and (iv) probabilistic quality on ID.

#### Hardware and toolchain.

We target two common MCU envelopes: a higher-capacity microcontroller with a few MB of flash and several hundred KB of SRAM (Big-MCU) and an ultra-low-power part with sub-MB flash and tens of KB SRAM (Small-MCU) (STMicroelectronics, 2019; 2018). Builds use the vendor toolchain with -O3; CMSIS-NN kernels are enabled where available. The clock is fixed at the datasheet nominal to avoid DVFS confounds.

#### Cost and runtime accounting.

Flash is reported from the final ELF after link-time garbage collection. Peak RAM comes from the linker map plus the *incremental* buffers for SNAP-UQ’s projectors/heads. Latency is end-to-end time per inference measured by the on-chip cycle counter with interrupts masked; each figure averages 1,000 runs (std. dev. shown). Energy (selected runs) integrates current over time using a shunt on the board rail.

#### Backbones and datasets.

Vision: MNIST, CIFAR-10, TinyImageNet (LeCun et al., 1998; Krizhevsky, 2009; Le & Yang, 2015). Audio: SpeechCommands v2 (Warden, 2018). Backbones: a 4-layer DSCNN for SpeechCommands (Zhang et al., 2018), a compact residual net for CIFAR-10 (Banbury et al., 2021), and a MobileNetV2-style model for TinyImageNet (Howard et al., 2017). Standard augmentation is used; temperature scaling is applied on the ID validation split. Full dataset and schedule details appear in Appx. [A](https://arxiv.org/html/2508.12907v1#A1) and [B](https://arxiv.org/html/2508.12907v1#A2).

#### SNAP-UQ configuration (inference-friendly).

We attach two taps (end of a mid block and the penultimate block). Each tap uses a $1{\times}1$ projector $P_{\ell}$ with global average pooling and two int8 heads that output $(\mu_{\ell},\log\sigma_{\ell}^{2})$. We set ranks $r_{\ell}\in\{32,64,128\}$ and auxiliary weight $\lambda_{\mathrm{SS}}\in\{10^{-3},10^{-2}\}$. To avoid exponentials on-device, $\log\sigma^{2}$ is clamped and mapped to per-channel multipliers via a 256-entry LUT. A 3-parameter logistic map converts $(S,m)$ to $U$; an isotonic alternative is reported in Appx. [J](https://arxiv.org/html/2508.12907v1#A10).

#### Baselines and tuning.

We compare against single-pass confidence (max-probability, entropy) (Hendrycks & Gimpel, 2017), temperature scaling, classwise Mahalanobis at tapped layers, energy-based scoring Liu et al. (2020), evidential posteriors when they fit, and—on Big-MCU only—MC Dropout (Gal & Ghahramani, 2016) and Deep Ensembles (Lakshminarayanan et al., 2017). All methods share backbones and input pipelines; thresholds and any temperature/isotonic parameters are tuned on a common development split. Implementation details and grids appear in Appx. [C](https://arxiv.org/html/2508.12907v1#A3).

#### CID/OOD protocols and streaming setup.

We use MNIST-C, CIFAR-10-C, TinyImageNet-C (Mu & Gilmer, 2019; Hendrycks & Dietterich, 2019). For SpeechCommands we synthesize CID using impulse responses, background noise, reverberation, and time/pitch perturbations (Appx. [D](https://arxiv.org/html/2508.12907v1#A4)). OOD sets are Fashion-MNIST (for MNIST), SVHN (for CIFAR-10), non-keyword/background audio (for SpeechCommands), and disjoint TinyImageNet classes. For *streaming* evaluation, we concatenate clean ID segments with CID segments of rising severity and short OOD bursts (Gama et al., 2014). Events are labeled offline via sliding-window accuracy (window $m{=}100$) falling below an ID band estimated from a held-out run ($\mu_{\text{ID}}\pm 3\sigma_{\text{ID}}$). The monitor never sees labels online. We score event detection by AUPRC and report thresholded detection delay; thresholds are selected offline on the dev split (Appx. [E](https://arxiv.org/html/2508.12907v1#A5)).

#### Metrics.

We report AUROC/AUPRC for ID$\checkmark$ — ID$\times$ and ID$\checkmark$ — OOD, risk–coverage curves for selective prediction, and ID calibration via NLL, Brier, and ECE (Gneiting & Raftery, 2007; Glenn et al., 1950; Guo et al., 2017); formal definitions are in Appx. [F](https://arxiv.org/html/2508.12907v1#A6).

## 4 Results

We evaluate *SNAP-UQ* on four axes: deployability on MCUs, monitoring under corrupted streams, failure detection (ID/CID and OOD), and probabilistic quality on ID. Unless noted, results are averaged over three seeds; 95% confidence intervals (CIs) are obtained via 1,000$\times$ bootstrap over examples. Ablations (tap placement/rank, quantization variants, mapping alternatives, risk–coverage surfaces, reliability diagrams, and error clusters) are deferred to Appendices [N](https://arxiv.org/html/2508.12907v1#A14)–[F](https://arxiv.org/html/2508.12907v1#A6). See Appendix [O](https://arxiv.org/html/2508.12907v1#A15) (Tables [11](https://arxiv.org/html/2508.12907v1#A15.T11)–[15](https://arxiv.org/html/2508.12907v1#A15.T15), Figs. [8](https://arxiv.org/html/2508.12907v1#A15.F8)–[9](https://arxiv.org/html/2508.12907v1#A15.F9)) for a single-pass head-to-head and decision-centric risk–coverage analyses.

### 4.1 On-device fit and runtime

Setup. All methods share the same backbones, preprocessing, and integer kernels. Builds use vendor toolchains with -O3 and CMSIS-NN where available; input I/O is excluded and timing spans from first byte in SRAM to posterior/uncertainty out. *Flash* is read from the final ELF (post link-time GC). *Peak RAM* is computed from the linker map plus scratch buffers required by the method. *Latency* is measured with the MCU cycle counter at datasheet nominal clock (interrupts masked), averaged over 1,000 runs. *Energy* integrates current over time via a calibrated shunt at 20 kHz. All baselines are compiled with the same quantization scheme; when a method does not fit, we report *OOM* and omit latency/energy.

Findings. Table [1](https://arxiv.org/html/2508.12907v1#S4.T1) summarizes deployability. On Big-MCU, SNAP-UQ reduces latency by 35% (SpeechCmd) and 24% (CIFAR-10) vs. EE-ens, and by 26–34% vs. DEEP, with 49–46% and 37–57% flash savings, respectively. On Small-MCU, both ensembles are *OOM* for CIFAR-10; for SpeechCmd, SNAP-UQ is 33% faster and 16–24% smaller, and uses 1.6–2.0$\times$ less peak RAM than EE-ens due to absent exit maps and int8 heads. These trends hold across seeds; CIs are narrow (typically $\pm$1–3% of the mean).

**Table 1: MCU deployability. Flash (KB) / Peak RAM (KB) / Latency (ms) / Energy (mJ). OOM: method does not fit.**
| Big-MCU (SpeechCmd) | BASE | EE-ens | DEEP | SNAP-UQ |
| --- | --- | --- | --- | --- |
| Flash $\downarrow$ | 220 | 360 | 290 | 182 |
| Peak RAM $\downarrow$ | 84 | 132 | 108 | 70 |
| Latency $\downarrow$ | 60 | 85 | 70 | 52 |
| Energy $\downarrow$ | 2.1 | 3.0 | 2.5 | 1.7 |
| Big-MCU (CIFAR-10) |  |  |  |  |
| Flash $\downarrow$ | 280 | 540 | 680 | 292 |
| Peak RAM $\downarrow$ | 128 | 190 | 176 | 120 |
| Latency $\downarrow$ | 95 | 110 | 125 | 83 |
| Energy $\downarrow$ | 3.7 | 4.1 | 4.6 | 3.3 |
| Small-MCU (SpeechCmd) |  |  |  |  |
| Flash $\downarrow$ | 140 | 320 | 210 | 118 |
| Peak RAM $\downarrow$ | 60 | 104 | 86 | 51 |
| Latency $\downarrow$ | 170 | 240 | 200 | 113 |
| Energy $\downarrow$ | 6.0 | 8.6 | 7.3 | 4.7 |
| Small-MCU (CIFAR-10) |  |  |  |  |
| Flash $\downarrow$ | 180 | OOM | OOM | 158 |
| Peak RAM $\downarrow$ | 92 | OOM | OOM | 85 |
| Latency $\downarrow$ | 260 | OOM | OOM | 178 |
| Energy $\downarrow$ | 9.5 | OOM | OOM | 6.4 |

### 4.2 Monitoring corrupted streams

Protocol. We construct unlabeled streams by concatenating ID segments, CID segments (severities 1–5 from MNIST-C/CIFAR-10-C/TinyImageNet-C or our SpeechCmd-C generator), and short OOD bursts. Ground-truth *events* are labeled offline when a sliding-window accuracy (window $m{=}100$) falls below an ID band estimated from a separate held-out ID run ($\mu_{\text{ID}}-3\sigma_{\text{ID}}$). Thresholds for each method are fixed on a development stream to maximize the F1 score and then held constant for evaluation. We report AUPRC and median detection delay (frames) at that single threshold.

Findings. SNAP-UQ yields the best average AUPRC and shortest delays on MNIST-C and SpeechCmd-C (Table [2](https://arxiv.org/html/2508.12907v1#S4.T2)), and its AUPRC grows fastest with severity on CIFAR-10-C (Fig. [2](https://arxiv.org/html/2508.12907v1#S4.F2)). Qualitatively, depth-wise surprisal reacts earlier than softmax entropy as distortions accumulate, reducing late alarms. False positives on clean ID segments remain low at matched recall (Appx [F](https://arxiv.org/html/2508.12907v1#A6)).

**Table 2: Accuracy-drop detection on CID streams. AUPRC (higher is better) and median detection delay (frames) at a single dev-chosen threshold.**
|  | MNIST-C | SpeechCmd-C |  |  |
| --- | --- | --- | --- | --- |
| Method | AUPRC $\uparrow$ | Delay $\downarrow$ | AUPRC $\uparrow$ | Delay $\downarrow$ |
| BASE | 0.54 | 42 | 0.52 | 67 |
| EE-ens | 0.63 | 31 | 0.59 | 55 |
| DEEP | 0.56 | 35 | 0.58 | 57 |
| SNAP-UQ | 0.66 | 24 | 0.65 | 41 |

Figure: Figure 2: CIFAR-10-C: AUPRC vs. corruption severity. SNAP-UQ scales fastest with severity.

### 4.3 Failure detection (ID, CID, OOD)

Tasks. We report AUROC for two threshold-free discriminations: ID$\checkmark$ — ID$\times$ (correct vs. incorrect among ID + CID) and ID$\checkmark$ — OOD (ID vs. OOD). For operational relevance, we further compare selective risk at fixed coverage and selective NLL in Appx [F](https://arxiv.org/html/2508.12907v1#A6).

Findings. With a single forward pass, SNAP-UQ leads on ID$\checkmark$ — ID$\times$ for MNIST and SpeechCmd and remains competitive on CIFAR-10; on ID$\checkmark$ — OOD, it ties the best on SpeechCmd and is close to the strongest semantic OOD detector on CIFAR-10 (Table [3](https://arxiv.org/html/2508.12907v1#S4.T3)). These gains mirror the monitoring results: when corruptions are label-preserving, depth-wise surprisal provides sharper separation than confidence-only scores.

**Table 3: Failure detection. AUROC for ID$\checkmark$ — ID$\times$ and ID$\checkmark$ — OOD.**
| Method | ID$\checkmark$ — ID$\times$ | ID$\checkmark$ — OOD |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| MNIST | SpCmd | cfr10 | MNIST | SpCmd | cfr10 |  |
| BASE | 0.75 | 0.90 | 0.84 | 0.07 | 0.90 | 0.88 |
| EE-ens | 0.85 | 0.90 | 0.85 | 0.87 | 0.90 | 0.90 |
| DEEP | 0.85 | 0.91 | 0.86 | 0.78 | 0.92 | 0.92 |
| G-ODIN | 0.72 | 0.74 | 0.83 | 0.40 | 0.74 | 0.95 |
| SNAP-UQ | 0.90 | 0.94 | 0.87 | 0.86 | 0.92 | 0.94 |

### 4.4 Calibration on ID

Metrics. We report Negative Log-Likelihood (NLL), Brier Score (BS), and Expected Calibration Error (ECE, 15 adaptive bins) on held-out ID splits. All methods use the same temperature scaling protocol unless otherwise specified; SNAP-UQ applies a lightweight logistic mapping (or isotonic in Appx) from surprisal (and optional confidence blend) to $U$.

Findings. SNAP-UQ improves proper scores on MNIST and SpeechCmd, lowering both NLL and BS while reducing ECE relative to BASE. On CIFAR-10, a capacity-matched variant (SNAP-UQ^+) matches DEEP on BS with comparable NLL, while preserving single-pass inference (Table [4](https://arxiv.org/html/2508.12907v1#S4.T4)). Reliability curves and selective-calibration analyses appear in Appx [F](https://arxiv.org/html/2508.12907v1#A6).

**Table 4: ID calibration. Lower is better. SNAP-UQ^+ increases projector rank and adds a low-rank covariance correction.**
| MNIST | NLL $\downarrow$ | BS $\downarrow$ | ECE $\downarrow$ |
| --- | --- | --- | --- |
| BASE | 0.285 | 0.012 | 0.028 |
| Temp. scaled | 0.242 | 0.010 | 0.022 |
| SNAP-UQ | 0.202 | 0.008 | 0.016 |
| SpeechCmd | NLL | BS | ECE |
| BASE | 0.306 | 0.012 | 0.024 |
| Temp. scaled | 0.228 | 0.009 | 0.021 |
| SNAP-UQ | 0.197 | 0.008 | 0.016 |
| CIFAR-10 | NLL | BS | ECE |
| BASE | 0.415 | 0.021 | 0.031 |
| DEEP | 0.365 | 0.017 | 0.015 |
| SNAP-UQ^+ | 0.363 | 0.017 | 0.021 |

## 5 Conclusion and Discussion

SNAP-UQ turns depth-wise next-activation prediction into a single-pass uncertainty signal that is compact, integer-friendly, and easy to deploy on microcontrollers. By attaching two–three tiny int8 heads at selected depths and mapping the resulting surprisal through a lightweight monotone function, SNAP-UQ improves on-device monitoring under corrupted streams, remains competitive for ID$\checkmark$ — ID$\times$ and ID$\checkmark$ — OOD failure detection, and strengthens ID calibration—while fitting within kilobyte-scale flash/RAM budgets where heavier baselines frequently exceed limits. The approach requires no temporal buffers, auxiliary exits, or repeated evaluations, and integrates cleanly with standard CMSIS-NN–style pipelines.

Despite these strengths, several limitations remain. First, some firmware stacks fuse or elide intermediate activations, so exposing taps may require minor runtime changes. Second, the diagonal (or low-rank+diag) covariance used by the heads cannot fully capture fine cross-channel structure, which can under- or over-penalize surprisal under extreme distortions. Third, performance is sensitive to tap placement and projector rank; suboptimal choices can erode gains. Fourth, while SNAP-UQ operates label-free, the optional confidence blend and logistic/isotonic mapping benefit from a small labeled development mix. Finally, our evaluation spans four benchmarks and two MCU tiers; broader modalities, longer field deployments, and alternative backbones (e.g., tiny transformers) are not yet covered, and specialized single-pass OOD scores can still lead on far-OOD cases with clean low-level statistics.

We see several promising directions. Hardware-aware search for taps and ranks could jointly optimize accuracy, latency, and memory under board-specific constraints. Richer heads—such as shared-structure low-rank+diag, mixture, or Student-*t* variants—may capture cross-channel and heavy-tailed behavior at near-constant cost. Self-tuning calibration with lightweight, budgeted controllers and drift-aware isotonic updates could preserve single-pass inference while reducing reliance on labels. A hybrid single-pass combiner that fuses depth-wise surprisal with one semantic OOD feature (e.g., energy or classwise Mahalanobis) may further improve failure detection. Finally, integrating with codegen toolchains (TVM/CMSIS) to expose tap tensors without extra copies.

## References

- Banbury et al. (2021)
Colby Banbury, Vijay Janapa Reddi, and et al.
Mlperf tiny benchmark.
In *Proceedings of MLSys*, 2021.
- Charpentier et al. (2020)
Bertrand Charpentier, Daniel Zügner, and Stephan Günnemann.
Posterior network: Uncertainty estimation without ood samples via density-based pseudo-counts.
*Advances in neural information processing systems*, 33:1356–1367, 2020.
- Deng et al. (2023)
Danruo Deng, Guangyong Chen, Yang Yu, Furui Liu, and Pheng-Ann Heng.
Uncertainty estimation by fisher information-based evidential deep learning.
In *International conference on machine learning*, pp.  7596–7616. PMLR, 2023.
- Djurisic et al. (2023)
Aleksandar Djurisic, Paul Michel, et al.
Ash: Principled activation shaping for out-of-distribution detection.
In *NeurIPS*, 2023.
- Gal & Ghahramani (2016)
Yarin Gal and Zoubin Ghahramani.
Dropout as a bayesian approximation: Representing model uncertainty in deep learning.
*ICML*, 2016.
- Gama et al. (2014)
João Gama, Indrė Žliobaitė, Albert Bifet, Mykola Pechenizkiy, and Abdelhamid Bouchachia.
A survey on concept drift adaptation.
*ACM Computing Surveys*, 46(4):1–37, 2014.
- Ghanathe & Wilton (2024)
Nikhil P Ghanathe and Steven J. E. Wilton.
Qute: Quantifying uncertainty in tinyml with early-exit-assisted ensembles for model monitoring.
*arXiv:2404.12599*, 2024.
- Glenn et al. (1950)
W Brier Glenn et al.
Verification of forecasts expressed in terms of probability.
*Monthly weather review*, 78(1):1–3, 1950.
- Gneiting & Raftery (2007)
Tilmann Gneiting and Adrian E Raftery.
Strictly proper scoring rules, prediction, and estimation.
*Journal of the American statistical Association*, 102(477):359–378, 2007.
- Guo et al. (2017)
Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q. Weinberger.
On calibration of modern neural networks.
In *ICML*, 2017.
- Hendrycks & Dietterich (2019)
Dan Hendrycks and Thomas Dietterich.
Benchmarking neural network robustness to common corruptions and perturbations.
In *ICLR*, 2019.
- Hendrycks & Gimpel (2017)
Dan Hendrycks and Kevin Gimpel.
A baseline for detecting misclassified and out-of-distribution examples in neural networks.
In *ICLR*, 2017.
- Howard et al. (2017)
Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam.
Mobilenets: Efficient convolutional neural networks for mobile vision applications.
*arXiv preprint arXiv:1704.04861*, 2017.
- Hsu et al. (2020)
Yen-Chang Hsu, Yilin Shen, Hongxia Jin, and Zsolt Kira.
Generalized odin: Detecting out-of-distribution image without learning from ood data.
In *CVPR*, 2020.
- Jacob et al. (2018)
Benoit Jacob, Skirmantas Kligys, Bo Chen, Menglong Zhu, Matthew Tang, Andrew Howard, Hartwig Adam, and Dmitry Kalenichenko.
Quantization and training of neural networks for efficient integer-arithmetic-only inference.
In *Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)*, 2018.
- Krizhevsky (2009)
Alex Krizhevsky.
Learning multiple layers of features from tiny images.
Technical Report TR-2009, University of Toronto, 2009.
Department of Computer Science.
- Lakshminarayanan et al. (2017)
Balaji Lakshminarayanan, Alexander Pritzel, and Charles Blundell.
Simple and scalable predictive uncertainty estimation using deep ensembles.
In *NeurIPS*, 2017.
- Le & Yang (2015)
Ya Le and Xuan Yang.
Tiny imagenet visual recognition challenge.
[http://cs231n.stanford.edu/](http://cs231n.stanford.edu/), 2015.
CS231N, 7(7):3.
- LeCun et al. (1998)
Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner.
Gradient-based learning applied to document recognition.
*Proceedings of the IEEE*, 86(11):2278–2324, November 1998.
doi: 10.1109/5.726791.
- Lee et al. (2018)
Kimin Lee, Kibok Lee, Honglak Lee, and Jinwoo Shin.
A simple unified framework for detecting out-of-distribution samples and adversarial attacks.
*Advances in neural information processing systems*, 31, 2018.
- Liang et al. (2018)
Shiyu Liang, Yixuan Li, and R. Srikant.
Enhancing the reliability of out-of-distribution image detection in neural networks.
In *ICLR*, 2018.
- Liu et al. (2020)
Weitang Liu, Xiaoyun Wang, John Owens, and Yixuan Li.
Energy-based out-of-distribution detection.
*Advances in neural information processing systems*, 33:21464–21475, 2020.
- Malinin & Gales (2018)
Andrey Malinin and Mark Gales.
Predictive uncertainty estimation via prior networks.
*Advances in neural information processing systems*, 31, 2018.
- Meronen et al. (2024)
Lassi Meronen, Martin Trapp, Andrea Pilzer, Le Yang, and Arno Solin.
Fixing overconfidence in dynamic neural networks.
In *Proceedings of the IEEE/CVF winter conference on applications of computer vision*, pp.  2680–2690, 2024.
- Minderer et al. (2021)
Matthias Minderer et al.
Revisiting the calibration of modern neural networks.
In *NeurIPS*, 2021.
- Mu & Gilmer (2019)
Norman Mu and Justin Gilmer.
Mnist-c: A robustness benchmark for computer vision.
*arXiv preprint arXiv:1906.02337*, 2019.
- Mukhoti et al. (2023)
Jishnu Mukhoti, Andreas Kirsch, Joost Van Amersfoort, Philip HS Torr, and Yarin Gal.
Deep deterministic uncertainty: A new simple baseline.
In *Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition*, pp.  24384–24394, 2023.
- Netzer et al. (2011)
Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y. Ng.
Reading digits in natural images with unsupervised feature learning.
In *NIPS Workshop on Deep Learning and Unsupervised Feature Learning*, pp.  1–9, December 2011.
URL [http://ufldl.stanford.edu/housenumbers](http://ufldl.stanford.edu/housenumbers).
SVHN dataset.
- Ovadia et al. (2019)
Yaniv Ovadia, Stanislav Fort, Jeremiah Ren, and et al.
Can you trust your model’s uncertainty? evaluating predictive uncertainty under dataset shift.
In *NeurIPS*, 2019.
- Platt (1999)
John Platt.
Probabilistic outputs for support vector machines and comparisons to regularized likelihood methods.
In *Advances in Large Margin Classifiers*. MIT Press, 1999.
- Qendro et al. (2021)
Lorena Qendro, Alexander Campbell, Pietro Lio, and Cecilia Mascolo.
Early exit ensembles for uncertainty quantification.
In *PMLR: ML4H*, 2021.
- Sensoy et al. (2018)
Murat Sensoy, Lance Kaplan, and Melih Kandemir.
Evidential deep learning to quantify classification uncertainty.
In *Advances in Neural Information Processing Systems (NeurIPS)*, 2018.
- STMicroelectronics (2018)
STMicroelectronics.
*STM32L432KC Datasheet: Ultra-low-power Arm Cortex-M4 32-bit MCU+FPU, 100 DMIPS, up to 256 KB Flash, 64 KB SRAM, USB FS, analog, audio*, 2018.
URL [https://www.st.com/resource/en/datasheet/stm32l432kc.pdf](https://www.st.com/resource/en/datasheet/stm32l432kc.pdf).
Accessed: 2025-08-08.
- STMicroelectronics (2019)
STMicroelectronics.
*STM32F767ZI Datasheet: ARM Cortex-M7 Microcontroller with 512 KB Flash, 216 MHz CPU, ART Accelerator, FPU, and Chrom-ART Accelerator*, 2019.
URL [https://www.st.com/resource/en/datasheet/stm32f767zi.pdf](https://www.st.com/resource/en/datasheet/stm32f767zi.pdf).
Accessed: 2025-08-08.
- Sun et al. (2021)
Weitang Sun, Y. Guo, F. Li, et al.
React: Out-of-distribution detection with rectified activations.
In *NeurIPS*, 2021.
- Van Amersfoort et al. (2020)
Joost Van Amersfoort, Lewis Smith, Yee Whye Teh, and Yarin Gal.
Uncertainty estimation using a single deep deterministic neural network.
In *International conference on machine learning*, pp.  9690–9700. PMLR, 2020.
- Warden (2018)
Pete Warden.
Speech commands: A dataset for limited-vocabulary speech recognition.
*arXiv preprint arXiv:1804.03209*, 2018.
- Xiao et al. (2017)
Han Xiao, Kashif Rasul, and Roland Vollgraf.
Fashion-mnist: A novel image dataset for benchmarking machine learning algorithms.
*arXiv preprint arXiv:1708.07747*, 2017.
- Zadrozny & Elkan (2002)
Bianca Zadrozny and Charles Elkan.
Transforming classifier scores into accurate multiclass probability estimates.
In *KDD*, 2002.
- Zhang et al. (2018)
Yundong Zhang, Naveen Suda, and Vikas Chandra.
Hello edge: Keyword spotting on microcontrollers.
In *Proceedings of the 3rd ACM/IEEE Symposium on Edge Computing (SEC)*, 2018.
arXiv:1711.07128 (2017).

## Appendix

## Appendix A Datasets and Preprocessing

#### Train/val/test splits and dev set.

For each dataset we follow the standard train/test split and carve out a *development* set from the official training portion for calibration and threshold selection (no test leakage). Unless noted otherwise, we reserve 10% of the training set as dev, stratified by class and fixed across seeds.

### A.1 Vision

#### MNIST.

60k/10k grayscale images at $28{\times}28$. We rescale to $28{\times}28$ with no interpolation, normalize using $\mu=0.1307$, $\sigma=0.3081$, and apply light augmentation: random affine rotation ($\pm 10^{\circ}$) and translation (up to 2 pixels). Batch size 256.

#### CIFAR-10.

50k/10k RGB images at $32{\times}32$. Augmentation: random crop with 4-pixel padding, horizontal flip $p{=}0.5$, Cutout $16{\times}16$ (optional; disabled on Small-MCU ablations), color jitter (brightness/contrast/saturation $\pm 0.2$). Normalization with per-channel means $(0.4914,0.4822,0.4465)$ and stds $(0.2023,0.1994,0.2010)$.

#### TinyImageNet.

200 classes, 100k train (500/class), 10k val (50/class), images at $64{\times}64$. We keep native $64{\times}64$. Augmentation: random resized crop to $64{\times}64$ (scale $[0.8,1.0]$), horizontal flip $p{=}0.5$, color jitter (0.2/0.2/0.2), and random grayscale $p{=}0.1$. Normalize with ImageNet statistics $\mu=(0.485,0.456,0.406)$, $\sigma=(0.229,0.224,0.225)$.

### A.2 Audio

#### SpeechCommands v2 (12-class KWS).

We follow the 12-class task: {yes, no, up, down, left, right, on, off, stop, go, unknown, silence}. Audio is mono at 16 kHz. We extract log-Mel features from 1 s clips using a 25 ms window, 10 ms hop, 512-point FFT, 40 Mel bands, and per-utterance mean/variance normalization (MVN). To avoid padding artifacts for shorter utterances we reflect-pad the waveform to 1 s. Augmentation: random time shift ($\pm$100 ms), background noise mixing (from the dataset’s noise clips) at SNR sampled uniformly from [5, 20] dB, small time/frequency masking (SpecAugment: up to 2 time masks of width 20 frames and 2 frequency masks of width 5 bins), and random gain $\pm 2$ dB.

### A.3 Corruptions (CID) and OOD

#### CID for vision.

We use MNIST-C, CIFAR-10-C, and TinyImageNet-C with all corruption types except *snow* for MNIST-C (not defined). Severities $\{1,\dots,5\}$ are evaluated individually and averaged. The corruption families include noise (Gaussian, shot, impulse), blur (defocus, glass, motion, zoom), weather (snow, frost, fog), and digital (contrast, brightness, pixelate, JPEG).

#### CID for SpeechCommands (SpeechCmd-C).

We synthesize label-preserving degradations with: room impulse responses (RT60 sampled in [0.2, 1.0] s), background noise mixing (UrbanSound8K and ESC-50 subsets or the dataset’s noise) for SNR in [0, 20] dB, band-limiting (Butterworth low/high/band-pass with random cutoffs), pitch shift $\pm 2$ semitones, time stretch $\times[0.9,1.1]$, and reverberation pre-delay [0, 20] ms. We map these to five severities by increasing SNR difficulty and transform magnitudes.

#### OOD sets.

MNIST $\to$ Fashion-MNIST; CIFAR-10 $\to$ SVHN; SpeechCommands $\to$ non-keyword speech and background noise; TinyImageNet $\to$ a disjoint 200-class subset not present in training (we use the official val set as ID and a curated 200-class slice from ImageNet-1k as OOD when computing ID$\checkmark$ — OOD; all OOD images are resized to $64{\times}64$ with bicubic interpolation and normalized identically).

### A.4 Reproducibility and bookkeeping

We fix three seeds $\{13,17,23\}$; all splits and corruptions are deterministically generated per seed. Dev/test leakage is prevented by constructing streams from the held-out dev (for threshold selection) and the official test (for final reporting). Per-example metrics are stored to enable 1,000$\times$ bootstrap CIs.

## Appendix B Training, Calibration, and Build Details

### B.1 Backbones and heads

#### DSCNN (KWS).

Four depthwise-separable conv blocks (channels: 64, 64, 64, 64) with BN+ReLU6, followed by global average pooling and a linear classifier. Input is $40{\times}98$ (Mel$\times$time). Parameter budget $\approx$130 k. SNAP taps: end of block 2 (mid) and block 4 (penultimate). Projector ranks $r_{\ell}\in\{32,64\}$. Heads are linear: $z_{\ell}\!\to\!\mu_{\ell}$ and $z_{\ell}\!\to\!\log\sigma_{\ell}^{2}$.

#### Compact ResNet (CIFAR-10).

ResNet-8/ResNet-10-like with three stages at widths 16/32/64, stride-2 downsampling at the first conv of each stage, GAP, and linear classifier. Params $\approx$0.3–0.5 M. Taps: end of stage 2 and penultimate stage. Ranks $r_{\ell}\in\{64,128\}$.

#### Tiny MobileNetV2 (TinyImageNet).

Width multiplier 0.5, input $64{\times}64$, inverted residual blocks with expansion 6, strides [2,2,2] across spatial downsampling, GAP, linear classifier. Params $\approx$1.3 M. Taps: end of a mid IR block and penultimate IR block. Ranks $r_{\ell}\in\{64,128\}$ (Small-MCU) or $\{128,160\}$ (Big-MCU).

### B.2 Optimization and schedules

#### MNIST.

Adam (betas 0.9/0.999), lr $1\mathrm{e}{-3}$ with cosine decay to $1\mathrm{e}{-5}$ over 50 epochs; batch 256; weight decay $1\mathrm{e}{-4}$. $\lambda_{\mathrm{SS}}{=}5\mathrm{e}{-3}$ (warm-up over first 5 epochs), $\lambda_{\mathrm{reg}}{=}1\mathrm{e}{-4}$. Optional detach of $a_{\ell}$ after epoch 10 if validation NLL stalls.

#### CIFAR-10.

SGD with momentum 0.9, weight decay $5\mathrm{e}{-4}$, cosine lr from 0.2 to $5\mathrm{e}{-4}$ over 200 epochs; batch 128. Label smoothing 0.1. MixUp $\alpha{=}0.2$ on Big-MCU only (disabled for Small-MCU reproducibility runs). $\lambda_{\mathrm{SS}}{=}1\mathrm{e}{-2}$ with linear ramp (first 20 epochs). Gradient clipping at global L2 norm 1.0.

#### TinyImageNet.

SGD momentum 0.9, wd $1\mathrm{e}{-4}$, cosine lr from 0.15 to $1\mathrm{e}{-4}$ over 220 epochs; batch 128. $\lambda_{\mathrm{SS}}{=}5\mathrm{e}{-3}$ (ramp 20 epochs). Optional EMA of model weights ($\tau{=}0.999$) for final eval.

#### SpeechCommands.

AdamW (wd $1\mathrm{e}{-3}$), lr $2\mathrm{e}{-3}$ with cosine to $1\mathrm{e}{-5}$ over 80 epochs; batch 256. SpecAugment enabled (Sec. [A](https://arxiv.org/html/2508.12907v1#A1)). $\lambda_{\mathrm{SS}}{=}5\mathrm{e}{-3}$; detach disabled (empirically stable on KWS).

### B.3 SNAP-UQ-specific knobs

#### Auxiliary head stability.

Log-variance is parameterized via softplus: $\sigma^{2}{=}\mathrm{softplus}(\xi)+\epsilon^{2}$, $\epsilon{=}10^{-4}$. We clamp $\log\sigma^{2}\in[\log 10^{-4},\log 10^{2}]$. Scale regularizer $\alpha_{\mathrm{var}}{=}1\mathrm{e}{-4}$; head weight decay $\alpha_{\mathrm{wd}}{=}5\mathrm{e}{-4}$.

#### Layer weights and normalization.

Per-layer loss uses dimension normalization ($1/d_{\ell}$) and weights $\omega_{\ell}$ set inversely proportional to the dev-set variance of $\bar{e}_{\ell}$ (rescaled so $\sum\omega_{\ell}{=}|\mathcal{S}|$).

#### QAT phase.

For MCU deployability we apply fake quantization to $P_{\ell}$ and head weights during the final 20% of epochs (int8 symmetric per-tensor scales), keeping loss computation in float32. We export int8 weights and a 256-entry LUT for $\exp(-\tfrac{1}{2}\log\sigma^{2})$.

### B.4 Calibration and thresholds

#### Temperature scaling (ID).

We fit temperature $T$ on the ID dev set to minimize NLL, then report ID calibration metrics (NLL/BS/ECE) with scaled logits. This is applied uniformly across all methods.

#### SNAP mapping.

We fit either (i) a 3-parameter logistic map $U{=}\sigma(\beta_{0}+\beta_{1}S+\beta_{2}m)$ via class-balanced logistic regression, or (ii) isotonic regression on $\psi{=}\gamma S+(1{-}\gamma)m$ ($\gamma$ tuned on dev). Unless stated, the main text uses logistic; isotonic results are in Appx. [J](https://arxiv.org/html/2508.12907v1#A10).

#### Selective prediction.

We determine the threshold $\tau$ on the dev split to attain a target coverage (e.g., 90%) or to maximize F1 on event frames in streaming experiments. The same $\tau$ is then held fixed on test streams.

### B.5 Build and measurement (MCU)

#### Toolchain.

Vendor GCC with -O3, LTO enabled; CMSIS-NN kernels for int8 conv/linear ops where available. We disable denormals and set –ffast-math for the heads on Big-MCU only (identical outputs within $<10^{-4}$ RMSE).

#### Quantization/export.

Weights for $P_{\ell}$, $W_{\mu}$, $W_{\log\sigma^{2}}$ are int8 per-tensor scaled; activations follow the backbone’s quantization. The standardized error uses a LUT on clamped $\log\sigma^{2}$ values and accumulates in int32 before a single dequantization to float16 (or fixed-point with shared scale) for the final aggregation.

#### Timing and energy.

Latency is measured with the on-chip DWT cycle counter; interrupts masked, input already in SRAM, and timing spans from first layer call to posteriors and $U(x)$. Energy is measured on selected runs by shunt integration at 20 kHz with temperature-compensated calibration; reported as mean$\pm$std over 1,000 inferences.

### B.6 What to log (for reproducibility)

We store: (i) train/val/test splits and corruption RNG seeds; (ii) per-epoch $\mathbb{E}[\bar{e}_{\ell}]$ and its variance; (iii) mapping parameters $(\beta_{0},\beta_{1},\beta_{2})$ or isotonic step function; (iv) MCU build flags, commit hash, and per-layer op counts; (v) raw per-example scores for bootstrap CIs.

## Appendix C Baselines and Tuning Details

All baselines share the *same* training data, backbones, input pipelines, and integer kernels as SNAP-UQ. Unless noted, calibration and threshold selection use the *ID development* split (10% of train; fixed across seeds). For streaming experiments, thresholds are selected *once* on a dev stream and held fixed for test streams; for AUROC/AUPRC we report threshold-free metrics.

### C.1 Score definitions and MCU notes

#### Max-probability (Conf).

Score $S_{\text{conf}}(x)=1-\max_{\ell}p_{\phi}(y{=}\ell\!\mid\!x)$. *MCU:* softmax run is present for classification; we reuse it. No extra memory.

#### Entropy.

$S_{\text{ent}}(x)=-\sum_{\ell=1}^{L}p_{\phi}(y{=}\ell\!\mid\!x)\log p_{\phi}(y{=}\ell\!\mid\!x)$. *MCU:* use LUT for $\log$ (256 entries) or float16; cost negligible vs. backbone.

#### Temperature scaling (Temp).

Calibrated probs $\tilde{p}(y\mid x)=\mathrm{softmax}(z/T)$ with scalar $T\!>\!0$ fitted on the ID dev set by minimizing NLL. Applied to BASE/Conf/Entropy and used for ID calibration in section [4.4](https://arxiv.org/html/2508.12907v1#S4.SS4). *MCU:* divide logits by $T$ in-place (float16), no parameter bloat.

#### Classwise Mahalanobis at taps (Maha).

At selected layers $\ell\in\mathcal{S}$ (same taps as SNAP), fit class means $\{\mu_{\ell,c}\}$ and a shared *diagonal* covariance $\hat{\Sigma}_{\ell}{=}\mathrm{diag}(\sigma_{\ell}^{2})$ on the *ID training* set (to avoid dev leakage). Score

$$ $S_{\text{maha}}(x)\;=\;\min_{c}\sum_{\ell\in\mathcal{S}}w_{\ell}\cdot\frac{1}{d_{\ell}}\big{(}a_{\ell}(x)-\mu_{\ell,c}\big{)}^{\top}\hat{\Sigma}_{\ell}^{-1}\big{(}a_{\ell}(x)-\mu_{\ell,c}\big{)}.$ (14) $$

*MCU:* diagonal inverse avoids matrix–vector multiplies; store $\mu_{\ell,c}$ in int8 with per-tensor scale; $w_{\ell}$ as int16 fixed-point. Memory grows with $L\cdot\sum_{\ell}d_{\ell}$; feasible for MNIST/SpeechCmd, borderline for TinyImageNet (we then keep *penultimate* tap only).

#### Energy-based scoring (EBM).

Logit energy $S_{\text{eng}}(x)=-\log\!\sum_{\ell}\exp(z_{\ell}/T_{\text{eng}})$, with $T_{\text{eng}}$ tuned on dev. Higher energy $\Rightarrow$ more uncertain. *MCU:* compute $\mathrm{LSE}$ in float16 with max-shift trick; negligible overhead.

#### Evidential posteriors (Evid).

Replace softmax with nonnegative evidence $e\in\mathbb{R}_{+}^{L}$, $\alpha=e+1$, $\mathbb{E}[p]=\alpha/\sum_{j}\alpha_{j}$. Train with Dirichlet-based loss (NLL plus regularizer encouraging low evidence on errors). Uncertainty scores: $S_{\text{ep}}(x)=1-\max_{\ell}\mathbb{E}[p_{\ell}]$ and *total uncertainty* $u=\frac{L}{\sum_{j}\alpha_{j}}$. *MCU:* adds a linear head for $e$ and ReLU; we quantize to int8. On Small-MCU for CIFAR-10 this is *OOM*; we report it only where it fits.

#### MC Dropout (MCD; Big-MCU only).

Enable dropout at inference and average over $N$ stochastic passes. Uncertainty: predictive entropy $H[\bar{p}]$ or mutual information $H[\bar{p}]-\overline{H[p]}$. We use $N\in\{5,10\}$, dropout rate as trained. *MCU:* requires $N$ forward passes $\Rightarrow$ $N{\times}$ latency/energy; omitted on Small-MCU.

#### Deep Ensembles (DEEP; Big-MCU only).

Train $M$ independently initialized replicas ($M\in\{3,5\}$). Uncertainty $H[\tfrac{1}{M}\sum_{m}p^{(m)}]$. *MCU:* $M$ passes and $M{\times}$ flash unless hosted externally; we deploy only on Big-MCU and mark *OOM* elsewhere.

### C.2 Hyperparameter grids and selection

We tune all scalar hyperparameters on the ID dev set (or dev stream for streaming tasks), then *freeze* them. Grids:

- •
Temp scaling: $T\in\{0.5,0.75,1.0,1.25,1.5,2.0,3.0\}$; select by lowest dev NLL.
- •
Energy temperature: $T_{\text{eng}}\in\{0.5,1.0,1.5,2.0\}$; select by best dev AUROC (ID$\checkmark$ — ID$\times$).
- •
Mahalanobis: covariance shrinkage $\lambda\in\{0,10^{-4},10^{-3}\}$ on the diagonal variance, tap weights $w_{\ell}\in\{(1,0),(0,1),(0.5,0.5)\}$ for 2 taps; select by dev AUROC (ID$\checkmark$ — ID$\times$).
- •
Evidential: evidence scale $\eta\in\{0.1,0.5,1.0\}$, regularizer $\lambda_{\text{evid}}\in\{10^{-4},10^{-3},10^{-2}\}$; choose by dev NLL and AUROC (ID$\checkmark$ — ID$\times$).
- •
MCD (Big-MCU): $N\in\{5,10\}$; score type $\in\{\text{pred.\ ent.},\text{MI}\}$; choose by dev AUROC (ID$\checkmark$ — ID$\times$) under a latency cap (device budget).
- •
DEEP (Big-MCU): $M\in\{3,5\}$; choose by dev AUROC subject to flash cap; if *OOM*, we report size-only or omit runtime.

### C.3 Thresholding and operating points

#### Streaming (accuracy-drop detection).

Each method outputs a scalar score $S(x_{t})$ increasing with uncertainty. On a *dev* stream (ID$\to$CID$\to$OOD), we select a single threshold $\tau^{\star}$ to maximize F1 for event frames (events labeled from sliding-window accuracy dips; Appx. [E](https://arxiv.org/html/2508.12907v1#A5)). We then *freeze* $\tau^{\star}$ and report AUPRC and median delay on test streams.

#### Selective prediction (risk–coverage).

On the ID dev split (or CID dev for corrupted selective risk), we scan thresholds to reach target coverage levels $\{50,60,\dots,95\}\%$ and report the error rate among accepted samples. For methods with a calibrated probability (Temp, Evid), we also report selective NLL on accepted samples.

#### Failure detection (ID ✓ \checkmark — ID × \times , ID ✓ \checkmark — OOD).

We report AUROC/AUPRC without thresholds. For completeness, we include a *dev-tuned* threshold (Youden’s J) when plotting confusion matrices (Appx. [F](https://arxiv.org/html/2508.12907v1#A6)).

### C.4 Fairness controls and implementation parity

To avoid confounds:

- 1.
Same backbones & preprocessing. Identical training augmentation, normalizers, and quantization settings across all methods.
- 2.
Single-pass baselines on Small-MCU. We exclude MCD/DEEP on Small-MCU due to multi-pass cost; other baselines are strictly single-pass.
- 3.
Calibration parity. Temperature scaling is applied to all softmax-based baselines for ID calibration. Energy uses its own $T_{\text{eng}}$; Evidential uses its native probabilities.
- 4.
Tapped layers parity. Mahalanobis uses the *same* tapped layers $\mathcal{S}$ as SNAP-UQ; if memory is tight, both methods use the penultimate tap only.
- 5.
Integer kernels. All inference runs use the same int8 CMSIS-NN backends; any float16/LUT steps (log, exp, LSE) are shared implementations.

### C.5 Memory/latency accounting on MCUs

We attribute incremental cost beyond the baseline backbone:

- •
Conf/Entropy/Temp: negligible flash; $<0.1$ ms latency for $L{\leq}200$.
- •
Energy: adds an LSE kernel (float16); $<0.2$ ms at $L{\leq}200$; no persistent state.
- •
Mahalanobis: flash grows with $\sum_{\ell}Ld_{\ell}$ (means) and $d_{\ell}$ (diag variance). For CIFAR-10 with 2 taps of size $d_{\ell}{\sim}256$ and $L{=}10$, storage $\approx$ 2 $\times$ 10 $\times$ 256 bytes $\approx$ 5 KB (int8 means) + scales; latency $<2$ ms.
- •
Evidential: adds one linear head ($d_{D}\!\times\!L$) and ReLU; typically $<10$ KB flash on KWS/CIFAR-10; latency $<1$ ms. May be *OOM* on Small-MCU for TinyImageNet.
- •
MCD/DEEP (Big-MCU only): latency/energy scale linearly with $N$ or $M$; flash scales with $M$ (unless remote).

### C.6 Reproducibility

We release (i) grids and chosen hyperparameters per seed, (ii) dev-set thresholds $\tau^{\star}$, (iii) feature statistics for Mahalanobis (int8 means/scales), (iv) evidence-head checkpoints, and (v) MCU build flags and per-layer timing. When a method is *OOM*, we include the measured maximum model that fits and report the shortfall.

### C.7 Limitations of baselines under TinyML constraints

Entropy and Temp rely solely on softmax shape, which can remain overconfident under CID; Mahalanobis with diagonal covariance is memory-light but ignores cross-channel structure; Energy depends on logit scale (mitigated by $T_{\text{eng}}$); Evidential adds parameters and can be unstable without careful regularization; MCD/DEEP provide stronger uncertainty but are incompatible with strict single-pass/flash budgets on Small-MCU.

## Appendix D CID/OOD Protocols and Streaming Setup

We standardize corruption sources, OOD sets, and a *single* streaming protocol shared by all methods so that thresholds are chosen once on a development stream and then frozen for evaluation.

### D.1 Corruption sources (CID)

#### Image.

We use MNIST-C, CIFAR-10-C, and TinyImageNet-C (Mu & Gilmer, 2019; Hendrycks & Dietterich, 2019). Each provides 15 corruption types at 5 severities (1=light, 5=strong). For TinyImageNet-C we resize to model input if needed but preserve severity labels.

#### Audio (SpeechCommands-C).

We synthesize label-preserving degradations using standard transforms:

- •
Room impulse responses (RIR): convolve with randomly sampled RIRs; reverberation $RT_{60}\in[0.2,0.8]$ s.
- •
Background mixing: mix with noise clips at SNR sampled uniformly from $[0,20]$ dB; noise drawn from the dataset’s _background_noise_ and external ambient recordings.
- •
Time/pitch perturbation: time-stretch factor in $[0.90,1.10]$; pitch shift in $\{-2,-1,0,+1,+2\}$ semitones (phase vocoding).
- •
Band-limiting & compression: a 2nd-order bandpass (300–3400 Hz) and light dynamic-range compression (soft knee).

We map “severity” 1–5 to tuples of SNR / $RT_{60}$ / stretch / pitch ranges so that larger severities jointly increase distortion while keeping labels invariant. Exact ranges and seeds are released with the code.

### D.2 Out-of-distribution (OOD) sets

- •
MNIST OOD: Fashion-MNIST test split (Xiao et al., 2017).
- •
CIFAR-10 OOD: SVHN test split (Netzer et al., 2011).
- •
SpeechCommands OOD: non-keyword utterances (the official “unknown” class) and background noise segments.
- •
TinyImageNet OOD: classes disjoint from the training label set (we use a held-out 100-class subset with no overlap).

### D.3 Streaming construction

We build long, unlabeled streams that interleave stable ID segments, progressively corrupted CID segments, and short OOD bursts.

- •
Segment lengths. Unless noted: ID segments of 2,000 frames; for each severity $s\in\{1,\dots,5\}$ a CID segment of 1,000 frames; OOD bursts of 100 frames inserted between CID severities.
- •
Order. ID $\rightarrow$ CID($s{=}1$)$\rightarrow$OOD$\,\rightarrow\,$CID($s{=}2$)$\rightarrow\,$OOD $\dots$ CID($s{=}5$). Corruption types are cycled every 200 frames within a severity to avoid single-type bias.
- •
Randomization. Each stream uses a fixed seed per dataset; we generate 3 independent seeds for reporting mean$\pm$CI.
- •
Hold-out. Development and evaluation streams are built from disjoint underlying data indices.

### D.4 Event labeling (offline, never seen online)

We mark *accuracy-drop events* without exposing labels to the online monitor:

- •
Baseline band. From a separate, long ID-only run we compute sliding-window accuracy with window $m=100$ frames to estimate $\mu_{\text{ID}}$ and $\sigma_{\text{ID}}$.
- •
Event rule. On a labeled copy of each stream, compute sliding-window accuracy (window $m=100$). An event is active when the windowed accuracy $<\mu_{\text{ID}}-3\sigma_{\text{ID}}$.
- •
Onset/offset and merging. The event onset is the first frame crossing the threshold. Adjacent events separated by fewer than $m$ frames are merged; events shorter than $m$ frames are discarded to reduce label noise.

### D.5 Threshold selection and scoring

#### Single operating point (for delay).

For each method, on the *dev stream* we select a single threshold $\tau^{\star}$ that maximizes F1 on event frames; $\tau^{\star}$ is then frozen and used to measure median detection delay on *test streams*. A detection is a threshold crossing while an event is active; the delay is the time from event onset to the first detection. Multiple crossings within the same event are ignored.

#### Threshold-free metrics.

We also report AUPRC over all thresholds (events as positives; non-events as negatives) to summarize detection quality independent of $\tau^{\star}$.

#### False positives on clean ID.

On the ID portions of the streams, we compute the false positive rate at fixed recall (e.g., 90%) by interpolating each method’s PR curve; these values are reported in the main text or Appx [F](https://arxiv.org/html/2508.12907v1#A6).

#### Confidence intervals.

We form 95% CIs by nonparametric bootstrap with 1,000 resamples: for AUPRC we resample frames; for delays we resample events. We report median and CI (2.5/97.5th percentiles).

### D.6 Reference implementation and reproducibility

We release configuration files specifying: (i) segment lengths and order, (ii) corruption type schedules and severity mappings, (iii) random seeds, and (iv) the ID band ($\mu_{\text{ID}},\sigma_{\text{ID}}$) per dataset. A lightweight script generates both *labeled* (for offline scoring only) and *unlabeled* (for online methods) streams from the same random seed to ensure comparability across baselines.

### D.7 Pseudocode (stream builder)

Figure: Algorithm 3 BuildStream$(\mathcal{D}_{\text{ID}},\mathcal{D}_{\text{CID}},\mathcal{D}_{\text{OOD}},m,\text{seed})$

### D.8 Notes for MCU playback

On-device playback preloads the stream into flash or streams from host over UART; timestamps are recorded from the on-chip cycle counter. We mask interrupts during the model invocation to stabilize latency and re-enable them during I/O. No labels or event markers are sent to the device.

## Appendix E Event-Detection Scoring: AUPRC and Delay

We evaluate streaming *event detection* with two complementary measures: (i) area under the precision–recall curve (AUPRC), threshold-free and frame-based; and (ii) *thresholded detection delay* at a single operating point selected on a development stream. Online monitors never observe labels; all scoring uses an offline labeled copy of the same streams.

### E.1 Notation

Let a test stream have frames $t=1,\dots,T$. Each frame carries a binary event label $y_{t}\in\{0,1\}$ (Sec. [D](https://arxiv.org/html/2508.12907v1#A4)): $y_{t}=1$ iff the sliding-window accuracy is below the ID band. A method outputs a scalar score $s_{t}\in[0,1]$ (higher means more likely in-event). Let $\mathcal{E}=\{(t_{k}^{\mathrm{on}},t_{k}^{\mathrm{off}})\}_{k=1}^{K}$ be disjoint event intervals with $y_{t}=1$ for $t\in[t_{k}^{\mathrm{on}},t_{k}^{\mathrm{off}}]$.

### E.2 AUPRC (frame-based, threshold-free)

We sweep thresholds over the set of unique scores $\Theta=\{s_{t}:t=1,\dots,T\}$. For a threshold $\tau$, predictions are $\hat{y}_{t}(\tau)=\mathbb{I}[s_{t}\geq\tau]$. Define

$$ $\mathrm{TP}(\tau)=\sum_{t}\mathbb{I}[y_{t}=1\land\hat{y}_{t}(\tau)=1],\quad\mathrm{FP}(\tau)=\sum_{t}\mathbb{I}[y_{t}=0\land\hat{y}_{t}(\tau)=1],\quad\mathrm{FN}(\tau)=\sum_{t}\mathbb{I}[y_{t}=1\land\hat{y}_{t}(\tau)=0].$ (15) $$

#### Optional event-weighted variant.

To reduce dominance of long events, we also report an *event-weighted* AUPRC in Appx [F](https://arxiv.org/html/2508.12907v1#A6) by giving each event equal total weight $\frac{1}{K}$ (and background weight $\frac{1}{K}$), implemented by per-frame weights that sum to one within each region.

### E.3 Threshold selection on the development stream

For each method, we select a single operating threshold $\tau^{\star}$ on a *development* stream (disjoint indices) by maximizing the frame-wise F1 score:

$$ $\tau^{\star}\in\arg\max_{\tau\in\Theta_{\mathrm{dev}}}\mathrm{F1}(\tau)=\frac{2\,P_{\mathrm{dev}}(\tau)\,R_{\mathrm{dev}}(\tau)}{P_{\mathrm{dev}}(\tau)+R_{\mathrm{dev}}(\tau)+\epsilon}.$ (16) $$

This $\tau^{\star}$ is frozen and used only for delay measurement on test streams. We also record the dev-set operating recall to match false-positive accounting on clean ID segments.

### E.4 Thresholded detection delay (test only)

Given $\tau^{\star}$, a *detection* for event $k$ is the first threshold crossing $\hat{t}_{k}=\min\{t\in[t_{k}^{\mathrm{on}},t_{k}^{\mathrm{off}}]:s_{t}\geq\tau^{\star}\}$, if it exists. The delay is

$$ $\mathrm{Delay}_{k}=\begin{cases}\hat{t}_{k}-t_{k}^{\mathrm{on}},&\text{if a crossing occurs;}\\ \mathrm{NaN},&\text{otherwise (missed event).}\end{cases}$ (17) $$

We ignore crossings before $t_{k}^{\mathrm{on}}$ for delay (they are counted as false positives elsewhere). Multiple crossings within an event are collapsed to the first. Adjacent events separated by fewer than $m$ frames are merged during labeling (Sec. [D](https://arxiv.org/html/2508.12907v1#A4)). We report the *median* delay over detected events and a 95% CI via bootstrap over events (1,000 resamples). We additionally report the miss rate $\frac{\#\{\mathrm{NaN}\}}{K}$.

#### Censoring.

If the stream ends before a detection while an event is active, the event is treated as missed for delay; sensitivity to this choice is analyzed in Appx [F](https://arxiv.org/html/2508.12907v1#A6).

### E.5 False positives on clean segments

At a matched recall (e.g., 90%) determined on the development stream, we compute the false positive rate on ID-only segments by applying the corresponding threshold on test streams and measuring the fraction of non-event frames flagged as events.

### E.6 Complexity and numerical details

Computing AUPRC requires sorting $\{s_{t}\}$ once: $O(T\log T)$ time and $O(T)$ memory. Delay uses a single pass at fixed $\tau^{\star}$: $O(T)$. To stabilize ties, we break equal scores by favoring higher recall first (stable sort), then precision.

### E.7 Pseudocode

Figure: Algorithm 4 DelayAtThreshold$(\{(t_{k}^{\mathrm{on}},t_{k}^{\mathrm{off}})\}_{k=1}^{K},\{s_{t}\}_{t=1}^{T},\tau^{\star})$

## Appendix F Metrics and Statistical Procedures

This appendix specifies how we compute all metrics reported in the main paper, including definitions, aggregation across seeds/datasets, calibration plots, and confidence intervals (CIs). Unless noted, scoring is *micro-averaged over examples* within each dataset/split.

### F.1 Notation and shared conventions

Let a dataset (or stream) produce examples indexed by $i=1,\dots,n$. The model outputs a class-probability vector $p_{i}\in\Delta^{L-1}$, a predicted label $\hat{y}_{i}=\arg\max_{\ell}p_{i,\ell}$, and an uncertainty score $u_{i}\in[0,1]$ (SNAP-UQ) or a baseline score $s_{i}\in\mathbb{R}$ where larger means “more uncertain”. The correctness indicator is $c_{i}=\mathbb{I}[\,\hat{y}_{i}=y_{i}\,]$. For OOD experiments we also have an OOD indicator $o_{i}\in\{0,1\}$ ($o_{i}=1$ iff OOD). For streaming event detection (Sec. [E](https://arxiv.org/html/2508.12907v1#A5)) we operate at the *frame* level; here we define non-streaming metrics.

### F.2 Failure detection: ROC/AUC and PR/AUPRC

#### ID ✓ \checkmark — ID × \times .

Positives are incorrect ID/CID predictions $(c_{i}=0)$; negatives are correct ID/CID predictions $(c_{i}=1)$. We rank by uncertainty (higher is more likely positive).

#### ID ✓ \checkmark — OOD.

Positives are OOD examples $(o_{i}=1)$; negatives are correct ID examples $(o_{i}=0\land c_{i}=1)$. We exclude incorrect ID examples to avoid conflating semantic shift with hard-ID errors.

#### ROC and AUROC.

For a threshold $\tau$, predict $\hat{z}_{i}(\tau)=\mathbb{I}[\,\text{score}_{i}\geq\tau\,]$, where $\text{score}_{i}$ is $u_{i}$ for SNAP-UQ or the baseline score. True/false positive rates are

$$ $\mathrm{TPR}(\tau)=\frac{\sum_{i}\mathbb{I}[z_{i}=1\land\hat{z}_{i}(\tau)=1]}{\sum_{i}\mathbb{I}[z_{i}=1]},\quad\mathrm{FPR}(\tau)=\frac{\sum_{i}\mathbb{I}[z_{i}=0\land\hat{z}_{i}(\tau)=1]}{\sum_{i}\mathbb{I}[z_{i}=0]},$ (18) $$

where $z_{i}$ encodes the task’s positive label. AUROC is the trapezoidal integral over the ROC curve obtained by sweeping $\tau$ over the unique scores in descending order. Ties are handled by stable sorting and averaging as in standard implementations.

#### PR and AUPRC.

Precision and recall at $\tau$ are

$$ $P(\tau)=\frac{\mathrm{TP}(\tau)}{\mathrm{TP}(\tau)+\mathrm{FP}(\tau)+\epsilon},\qquad R(\tau)=\frac{\mathrm{TP}(\tau)}{\mathrm{TP}(\tau)+\mathrm{FN}(\tau)+\epsilon},$ (19) $$

with $\epsilon=10^{-12}$. AUPRC uses stepwise-in-recall integration (VOC-style): if $(R_{i},P_{i})$ are points in decreasing $\tau$, $R_{0}=0$, then $\mathrm{AUPRC}=\sum_{i}(R_{i}-R_{i-1})\,\max_{j\leq i}P_{j}$.

#### Aggregation across corruptions.

For “$-$C” datasets (e.g., CIFAR-10-C), we compute the metric per *severity* and *corruption type* and report the mean over severities and types. Severity curves in the main text average over corruption types at each severity.

### F.3 Selective prediction: risk–coverage and selective NLL

Let an acceptance function $A_{i}(\tau)=\mathbb{I}[\,u_{i}<\tau\,]$ (lower uncertainty means accept). Coverage and risk at threshold $\tau$ are

$$ $\mathrm{Cov}(\tau)=\frac{1}{n}\sum_{i}A_{i}(\tau),\qquad\mathrm{Risk}(\tau)=\frac{\sum_{i}A_{i}(\tau)\,\mathbb{I}[\,\hat{y}_{i}\neq y_{i}\,]}{\sum_{i}A_{i}(\tau)+\epsilon}.$ (20) $$

We sweep $\tau$ to plot risk vs. coverage. When we report a single operating point (e.g., 90% coverage), $\tau$ is chosen to achieve the closest coverage from above.

#### Selective NLL.

At threshold $\tau$, the negative log-likelihood on *accepted* samples is

$$ $\mathrm{sNLL}(\tau)=\frac{\sum_{i}A_{i}(\tau)\,\big{(}-\log p_{i,y_{i}}\big{)}}{\sum_{i}A_{i}(\tau)+\epsilon}.$ (21) $$

This quantifies probabilistic quality conditioned on acceptance.

### F.4 ID calibration metrics

Unless noted, ID calibration is computed on held-out ID splits with the classifier’s posteriors $p_{i}$.

#### Negative log-likelihood (NLL).

$$ $\mathrm{NLL}=\frac{1}{n}\sum_{i=1}^{n}-\log p_{i,y_{i}}.$ (22) $$

#### Brier score (multi-class).

With one-hot target $e_{y_{i}}$,

$$ $\mathrm{BS}=\frac{1}{n}\sum_{i=1}^{n}\frac{1}{L}\left\|\,p_{i}-e_{y_{i}}\,\right\|_{2}^{2}.$ (23) $$

#### Expected calibration error (ECE).

We bin confidences $q_{i}=\max_{\ell}p_{i,\ell}$ into $B$ *adaptive* bins of (approximately) equal mass (we use $B=15$). For bin $b$ with index set $\mathcal{I}_{b}$,

$$ $\mathrm{acc}(b)=\frac{1}{|\mathcal{I}_{b}|}\sum_{i\in\mathcal{I}_{b}}\mathbb{I}[\,\hat{y}_{i}=y_{i}\,],\quad\mathrm{conf}(b)=\frac{1}{|\mathcal{I}_{b}|}\sum_{i\in\mathcal{I}_{b}}q_{i}.$ (24) $$

ECE is

$$ $\mathrm{ECE}=\sum_{b=1}^{B}\frac{|\mathcal{I}_{b}|}{n}\,\big{|}\,\mathrm{acc}(b)-\mathrm{conf}(b)\,\big{|}.$ (25) $$

Bins with $|\mathcal{I}_{b}|=0$ are skipped. Reliability diagrams plot $\mathrm{acc}(b)$ vs. $\mathrm{conf}(b)$ with bin widths proportional to $|\mathcal{I}_{b}|/n$.

#### Selective calibration.

When we evaluate calibration among accepted samples at a fixed coverage $\kappa$, we recompute NLL/BS/ECE on the subset $\{i:A_{i}(\tau_{\kappa})=1\}$ where $\tau_{\kappa}$ yields coverage $\kappa$.

### F.5 Confidence intervals and significance

For *per-dataset* metrics we form 95% CIs by nonparametric bootstrap with 1,000 resamples:

- •
For AUROC/AUPRC, NLL, BS, ECE, selective metrics: resample examples with replacement.
- •
For corruption-severity curves: at each severity, resample examples; then average across corruption types.
- •
For streaming event metrics (AUPRC, delay): see Sec. [E](https://arxiv.org/html/2508.12907v1#A5); we resample frames for AUPRC and events for delay.

We report point estimates as the mean over seeds and the CI as the 2.5/97.5th percentiles across bootstraps, applied independently per seed and then averaged (this avoids seed-mixing artifacts). When comparing two methods, we report a paired bootstrap CI on the *difference* by resampling indices shared across both methods.

### F.6 Implementation details and numerics

- •
Score direction. All scores are oriented so that larger values indicate *higher* likelihood of the positive class (error/OOD/event). If a baseline produces a confidence-like score, we negate it.
- •
Ties. We break ties in descending threshold order and use right-continuous step functions for PR; this matches common toolkits (e.g., scikit-learn) and yields stable AUPRC.
- •
Epsilon. We use $\epsilon=10^{-12}$ in denominators to avoid division by zero; this does not affect plotted values at the reported precisions.
- •
Seed averaging. For each dataset, we compute the metric per seed, then average those metrics; CIs are computed per seed and then averaged (“average CI”) to avoid over-narrowing from pooling examples across seeds.
- •
Unit handling. Delays are reported in frames; when converting to milliseconds on MCU streams, we multiply by the measured per-inference latency on the same board/backbone.

### F.7 Event-weighted PR

Long events can dominate frame-based PR. We therefore report, when indicated, an event-weighted AUPRC in which each event contributes equal mass. Let $\mathcal{E}$ be the set of events and $\mathcal{B}$ the background; we assign weight $w_{t}=1/|\mathcal{E}|$ to frames within an event (distributed uniformly within each event) and $w_{t}=1/|\mathcal{E}|$ to background frames in total, normalized to $\sum_{t}w_{t}=1$. Precision and recall are computed with these weights, and integration proceeds as above.

### F.8 Dataset-level aggregation

When we present a single number across multiple datasets (e.g., average AUPRC across MNIST-C and SpeechCmd-C), we macro-average dataset metrics (simple mean of per-dataset scores) to avoid size bias. For CIFAR-10-C and TinyImageNet-C we macro-average across severities and corruption types as described earlier.

### F.9 Reproducibility checklist

We release (i) the exact bin boundaries for adaptive ECE, (ii) per-threshold PR/ROC points for each method, (iii) per-seed bootstrap indices, and (iv) the list of thresholds used for selective metrics (coverage grid $\{0.5,0.6,\dots,0.99\}$ unless noted).

## Appendix G Training Objective and Regularization: Extended Details

This appendix expands section[2.2](https://arxiv.org/html/2508.12907v1#S2.SS2): we restate the objective with layer weighting, derive gradients in a numerically stable parameterization, discuss collapse/overdispersion failure modes and how our regularizers address them, and give practical schedules and pseudocode.

### G.1 Objective, layer weighting, and normalization

For tapped layers $\mathcal{S}$, define per-layer diagonal-Gaussian NLL

$$ $\ell_{\ell}(x)=\tfrac{1}{2}\Big{(}\|(a_{\ell}-\mu_{\ell})\odot\sigma_{\ell}^{-1}\|_{2}^{2}+\mathbf{1}^{\top}\log\sigma_{\ell}^{2}\Big{)},\qquad a_{\ell}\in\mathbb{R}^{d_{\ell}}.$ (26) $$

We use dimension-normalized losses to avoid bias toward larger $d_{\ell}$:

$$ $\bar{\ell}_{\ell}(x)=\frac{1}{d_{\ell}}\,\ell_{\ell}(x),\qquad\mathcal{L}_{\mathrm{SS}}=\frac{1}{|\mathcal{B}|}\sum_{x\in\mathcal{B}}\sum_{\ell\in\mathcal{S}}\omega_{\ell}\,\bar{\ell}_{\ell}(x),$ (27) $$

with nonnegative layer weights $\omega_{\ell}$ that sum to $|\mathcal{S}|$. Good defaults are (i) uniform $\omega_{\ell}{=}1$, or (ii) inverse-variance weights $\omega_{\ell}\propto 1/\widehat{\mathrm{Var}}[\bar{e}_{\ell}]$ (estimated on the dev split), which de-emphasize noisy taps. The total loss is

$$ $\mathcal{L}=\mathcal{L}_{\mathrm{clf}}+\lambda_{\mathrm{SS}}\,\mathcal{L}_{\mathrm{SS}}+\lambda_{\mathrm{reg}}\,\mathcal{R}.$ (28) $$

#### Regularizers.

We use:

- •
Variance floor. Parametrize $\sigma_{\ell,i}^{2}=\mathrm{softplus}(\xi_{\ell,i})+\epsilon^{2}$ with $\epsilon\in[10^{-4},10^{-3}]$ to prevent collapse (Sec. [G.3](https://arxiv.org/html/2508.12907v1#A7.SS3)).
- •
Scale control. $\mathcal{R}_{\mathrm{var}}=\sum_{\ell,i}\big{|}\log\sigma_{\ell,i}^{2}\big{|}$ discourages runaway over/under-dispersion.
- •
Weight decay. Standard $\ell_{2}$ on $P_{\ell}$ and head weights.
- •
Detach option. Optional $\texttt{stop_grad}(a_{\ell})$ inside $\mathcal{L}_{\mathrm{SS}}$ for small backbones (reduces optimization tug-of-war).

Thus $\mathcal{R}=\alpha_{\mathrm{var}}\mathcal{R}_{\mathrm{var}}+\alpha_{\mathrm{wd}}\|\theta_{\text{heads}}\|_{2}^{2}$ with small $\alpha_{\mathrm{var}}$ (e.g., $10^{-4}$) and standard weight decay (e.g., $5{\times}10^{-4}$).

### G.2 Stable parameterizations and exact gradients

We differentiate w.r.t. $(\mu_{\ell},s_{\ell})$ where $s_{\ell,i}=\log\sigma_{\ell,i}^{2}$ is the log-variance (or the pre-softplus $\xi_{\ell,i}$, see below).

For a single channel $i$:

$$ $\displaystyle\ell_{\ell,i}$ $\displaystyle=\tfrac{1}{2}\Big{(}\tfrac{(a_{\ell,i}-\mu_{\ell,i})^{2}}{e^{s_{\ell,i}}}+s_{\ell,i}\Big{)}.$ (29) $\displaystyle\frac{\partial\ell_{\ell,i}}{\partial\mu_{\ell,i}}$ $\displaystyle=\frac{\mu_{\ell,i}-a_{\ell,i}}{e^{s_{\ell,i}}}=\frac{\mu_{\ell,i}-a_{\ell,i}}{\sigma_{\ell,i}^{2}},$ (30) $\displaystyle\frac{\partial\ell_{\ell,i}}{\partial s_{\ell,i}}$ $\displaystyle=\tfrac{1}{2}\Big{(}1-\tfrac{(a_{\ell,i}-\mu_{\ell,i})^{2}}{e^{s_{\ell,i}}}\Big{)}=\tfrac{1}{2}\Big{(}1-\tfrac{(a_{\ell,i}-\mu_{\ell,i})^{2}}{\sigma_{\ell,i}^{2}}\Big{)}.$ (31) $$

With dimension-normalization,
$\partial\bar{\ell}_{\ell}/\partial\mu_{\ell}=\frac{1}{d_{\ell}}\,\partial\ell_{\ell}/\partial\mu_{\ell}$ and similarly for $s_{\ell}$.

#### Softplus parameterization.

Set $\sigma_{\ell,i}^{2}=\mathrm{softplus}(\xi_{\ell,i})+\epsilon^{2}$ with small $\epsilon$. Then

$$ $\displaystyle\frac{\partial\ell_{\ell,i}}{\partial\xi_{\ell,i}}=\Big{(}\frac{\partial\ell_{\ell,i}}{\partial\sigma_{\ell,i}^{2}}\Big{)}\cdot\frac{\partial\sigma_{\ell,i}^{2}}{\partial\xi_{\ell,i}}=\tfrac{1}{2}\Big{(}\frac{1}{\sigma_{\ell,i}^{2}}-\frac{(a_{\ell,i}-\mu_{\ell,i})^{2}}{(\sigma_{\ell,i}^{2})^{2}}\Big{)}\cdot\mathrm{sigmoid}(\xi_{\ell,i}),$ (32) $$

which avoids exploding gradients when $s_{\ell,i}\!\to\!-\infty$ and enforces positivity.

#### Backprop to P ℓ P_{\ell} and head weights.

Let $z_{\ell}=P_{\ell}a_{\ell-1}$ and $(\mu_{\ell},s_{\ell})=g_{\ell}(z_{\ell})$. Then

$$ $\displaystyle\frac{\partial\mathcal{L}_{\mathrm{SS}}}{\partial z_{\ell}}$ $\displaystyle=(J_{\mu,\ell})^{\top}\frac{\partial\mathcal{L}_{\mathrm{SS}}}{\partial\mu_{\ell}}+(J_{s,\ell})^{\top}\frac{\partial\mathcal{L}_{\mathrm{SS}}}{\partial s_{\ell}},$ (33) $\displaystyle\frac{\partial\mathcal{L}_{\mathrm{SS}}}{\partial P_{\ell}}$ $\displaystyle=\frac{\partial\mathcal{L}_{\mathrm{SS}}}{\partial z_{\ell}}\,a_{\ell-1}^{\top},$ (34) $$

where $J_{\mu,\ell}=\partial\mu_{\ell}/\partial z_{\ell}$ and $J_{s,\ell}=\partial s_{\ell}/\partial z_{\ell}$ are the head Jacobians (linear for our tiny heads).

### G.3 Failure modes and stabilization

#### Variance collapse ( σ 2 ↓ \sigma^{2}\!\downarrow ).

If the head overfits and drives $\sigma^{2}\!\to\!0$, the quadratic term explodes and training destabilizes. The *variance floor* and L1 *scale control* counteract this by (i) bounding the smallest variance via $\epsilon^{2}$ and (ii) penalizing extreme log-variances.

#### Overdispersion ( σ 2 ↑ \sigma^{2}\!\uparrow ).

Conversely, trivially inflating $\sigma^{2}$ reduces the quadratic term but increases $\sum\log\sigma^{2}$; $\mathcal{R}_{\mathrm{var}}$ and weight decay prevent such drift. Monitoring $\mathbb{E}[\bar{e}_{\ell}]$ on ID (expected $\approx 1$; Appx. [H.5](https://arxiv.org/html/2508.12907v1#A8.SS5)) offers a simple sanity check.

#### Gradient tug-of-war.

On tiny backbones, $\mathcal{L}_{\mathrm{SS}}$ and $\mathcal{L}_{\mathrm{clf}}$ may momentarily push $a_{\ell}$ in different directions. Two mitigations work well: (i) detach $a_{\ell}$ in $\mathcal{L}_{\mathrm{SS}}$; (ii) gradient balancing, scaling $\lambda_{\mathrm{SS}}$ to keep the ratio $\rho=\|\nabla\mathcal{L}_{\mathrm{SS}}\|/\|\nabla\mathcal{L}_{\mathrm{clf}}\|\in[0.05,0.2]$ (EMA-smoothed).

### G.4 Choosing λ SS \lambda_{\mathrm{SS}} and λ reg \lambda_{\mathrm{reg}}

#### Fixed grid (simple).

$\lambda_{\mathrm{SS}}\in\{10^{-3},5{\times}10^{-3},10^{-2}\}$, pick by dev AUPRC on CID; $\lambda_{\mathrm{reg}}$ so that $\mathcal{R}$ contributes 1–5% of $\mathcal{L}$ on the first epoch.

#### Adaptive (balanced).

Update $\lambda_{\mathrm{SS}}$ after each step:

$$ $\lambda_{\mathrm{SS}}\leftarrow\mathrm{clip}\Big{(}\lambda_{\mathrm{SS}}\cdot\frac{\rho^{\star}}{\widehat{\rho}},\,\lambda_{\min},\,\lambda_{\max}\Big{)},$ (35) $$

with target $\rho^{\star}\!=\!0.1$, $\widehat{\rho}$ an EMA of gradient-norm ratio, and bounds $(\lambda_{\min},\lambda_{\max})=(10^{-4},10^{-2})$.

### G.5 Robust variants and their gradients

As in section [2.2](https://arxiv.org/html/2508.12907v1#S2.SS2), two robust alternatives replace the quadratic:

#### Student- t t (diag).

With dof $\nu_{\ell}{>}0$,

$$ $\displaystyle\ell^{(t)}_{\ell,i}$ $\displaystyle=\frac{\nu_{\ell}+1}{2}\log\Big{(}1+\frac{(a_{\ell,i}-\mu_{\ell,i})^{2}}{\nu_{\ell}\sigma_{\ell,i}^{2}}\Big{)}+\tfrac{1}{2}\log\sigma_{\ell,i}^{2},$ (36) $\displaystyle\frac{\partial\ell^{(t)}_{\ell,i}}{\partial\mu_{\ell,i}}$ $\displaystyle=\frac{\nu_{\ell}+1}{\nu_{\ell}\sigma_{\ell,i}^{2}+(a_{\ell,i}-\mu_{\ell,i})^{2}}\,(\mu_{\ell,i}-a_{\ell,i}),$ (37) $\displaystyle\frac{\partial\ell^{(t)}_{\ell,i}}{\partial s_{\ell,i}}$ $\displaystyle=\tfrac{1}{2}\Big{[}1-\frac{\nu_{\ell}+1}{\nu_{\ell}+(a_{\ell,i}-\mu_{\ell,i})^{2}/\sigma_{\ell,i}^{2}}\cdot\frac{(a_{\ell,i}-\mu_{\ell,i})^{2}}{\sigma_{\ell,i}^{2}}\cdot\frac{1}{\nu_{\ell}}\Big{]}.$ (38) $$

Gradients are automatically clipped for large residuals, improving heavy-tail robustness.

#### Huberized Gaussian.

Replace $r=(a{-}\mu)/\sigma$ with Huber $\rho_{\delta}(r)$:

$$ $\displaystyle\ell^{(H)}_{\ell,i}$ $\displaystyle=\rho_{\delta}(r_{\ell,i})+\tfrac{1}{2}\log\sigma_{\ell,i}^{2},$ (39) $\displaystyle\frac{\partial\ell^{(H)}_{\ell,i}}{\partial\mu_{\ell,i}}$ $\displaystyle=\psi_{\delta}(r_{\ell,i})\cdot(-\sigma_{\ell,i}^{-1}),\qquad\psi_{\delta}(r)=\begin{cases}r,&|r|\leq\delta,\\ \delta\,\mathrm{sign}(r),&|r|>\delta.\end{cases}$ (40) $$

### G.6 Schedules, clipping, and QAT

#### Schedules.

Cosine LR with 5–10 epoch warm-up (Appx. [B](https://arxiv.org/html/2508.12907v1#A2)). Start with $\lambda_{\mathrm{SS}}$ small; optionally ramp it linearly over the first 10% of epochs.

#### Gradient clipping.

Global L2 clip at 1.0; per-parameter clips on $\xi$ (log-variance pre-activations) at $\pm 8$ are also effective.

#### QAT.

Insert fake quantization on $P_{\ell}$ and head weights for the last 20% of training; quantize $\log\sigma^{2}$ to 8-bit with a shared scale per head. Keep the loss in float32 during training for stability; on device, use the LUT strategy in Appx. [M](https://arxiv.org/html/2508.12907v1#A13).

### G.7 Implementation notes and pseudocode

Figure: Algorithm 5 Stable SNAP-UQ step (training)

#### Numerical tips.

(i) Clamp $s_{\ell}$ to $[\log\sigma_{\min}^{2},\log\sigma_{\max}^{2}]$ with $(\sigma_{\min}^{2},\sigma_{\max}^{2})=(10^{-4},10^{2})$;
(ii) maintain EMA of per-layer $\mathbb{E}[\bar{e}_{\ell}]$; values $\gg 1$ on ID suggest underfit heads; $\ll 1$ suggests overdispersion.

### G.8 Diagnostics and sanity checks

On a clean ID validation split:

- 1.
$\mathbb{E}[\bar{e}_{\ell}]\approx 1$ and $\mathrm{Var}[\bar{e}_{\ell}]\approx 2/d_{\ell}$ (Appx. [H.5](https://arxiv.org/html/2508.12907v1#A8.SS5)).
- 2.
$\mathrm{Corr}\big{(}\bar{e}_{\ell},\,1{-}C_{\phi}\big{)}$ should be positive but $<1$ (captures complementary signal).
- 3.
Freezing $g_{\ell}$ and re-fitting only the mapping (logistic/isotonic) should preserve ranking of $S(x)$.

### G.9 From training to deployment

After training, retain $P_{\ell}$ and linear heads for $(\mu_{\ell},\log\sigma_{\ell}^{2})$ (int8 weights). Export per-head scales/zero-points and the LUT for $\exp(-\tfrac{1}{2}\log\sigma^{2})$ (256 entries suffice). Fit the monotone mapping (3-parameter logistic or isotonic, Appx. [J](https://arxiv.org/html/2508.12907v1#A10)) on a small dev set mixing ID and representative shifts; store mapping parameters or a compact lookup table. No online labels are needed at inference.

Takeaway. The diagonal-Gaussian auxiliary loss supplies clean, closed-form gradients and—paired with a variance floor, light scale control, and optional detachment—trains stably on tiny backbones. Its dimension-normalized, layer-weighted form makes heads comparable across taps and preserves MCU deployability.

## Appendix H Proofs and Additional Derivations

This section provides detailed proofs for the propositions in section [2](https://arxiv.org/html/2508.12907v1#S2), plus auxiliary derivations used in the main text.

### H.1 Notation

For a tapped layer $\ell\in\mathcal{S}$, activations have dimension $d_{\ell}$. The SNAP predictor produces $(\mu_{\ell},\log\sigma_{\ell}^{2})$ from $z_{\ell}=P_{\ell}a_{\ell-1}$; we write $\Sigma_{\ell}\!=\!\mathrm{diag}(\sigma_{\ell}^{2})$, $v_{\ell}=a_{\ell}-\mu_{\ell}$, and define the standardized error

$$ $e_{\ell}(x)=\big{\|}v_{\ell}\odot\sigma_{\ell}^{-1}\big{\|}_{2}^{2}=\sum_{i=1}^{d_{\ell}}\frac{(a_{\ell,i}-\mu_{\ell,i})^{2}}{\sigma_{\ell,i}^{2}}.$ (41) $$

The SNAP score is $S(x)=\sum_{\ell\in\mathcal{S}}w_{\ell}\,\bar{e}_{\ell}(x)$ with $\bar{e}_{\ell}=e_{\ell}/d_{\ell}$ and $\sum_{\ell}w_{\ell}=1$.

### H.2 Proof of Proposition 2.1 (Surprisal–likelihood equivalence)

Under the diagonal-Gaussian conditional model
$p_{\theta}(a_{\ell}\mid a_{\ell-1})=\mathcal{N}\!\big{(}\mu_{\ell},\Sigma_{\ell}\big{)}$, the negative log-likelihood is

$$ $\displaystyle-\log p_{\theta}(a_{\ell}\mid a_{\ell-1})$ $\displaystyle=\tfrac{1}{2}\Big{[}(a_{\ell}-\mu_{\ell})^{\top}\Sigma_{\ell}^{-1}(a_{\ell}-\mu_{\ell})+\log\det\Sigma_{\ell}+d_{\ell}\log(2\pi)\Big{]}$ (42) $\displaystyle=\tfrac{1}{2}e_{\ell}(x)+\tfrac{1}{2}\sum_{i=1}^{d_{\ell}}\log\sigma_{\ell,i}^{2}+\tfrac{d_{\ell}}{2}\log(2\pi).$ (43) $$

Averaging (or weighting) across taps yields

$$ $\sum_{\ell\in\mathcal{S}}w_{\ell}\,\frac{2}{d_{\ell}}\Big{(}-\log p_{\theta}(a_{\ell}\mid a_{\ell-1})\Big{)}=\sum_{\ell\in\mathcal{S}}w_{\ell}\,\bar{e}_{\ell}(x)+\text{const},$ (44) $$

where the constant depends only on $\{\sigma_{\ell}\}$ (and $d_{\ell}$). Thus $S(x)$ is an affine transform of the depth-wise NLL and is therefore order-equivalent as an uncertainty score. ∎

### H.3 Proof of Proposition 2.2 (Relation to Mahalanobis)

Assume a linear-Gaussian depth-wise feature evolution

$$ $a_{\ell}=W_{\ell}a_{\ell-1}+b_{\ell}+\varepsilon_{\ell},\qquad\varepsilon_{\ell}\sim\mathcal{N}(0,\Sigma_{\ell}).$ (45) $$

Then $\mu_{\ell}=W_{\ell}a_{\ell-1}+b_{\ell}$ is the conditional mean and

$$ $\displaystyle e_{\ell}(x)$ $\displaystyle=(a_{\ell}-\mu_{\ell})^{\top}\Sigma_{\ell}^{-1}(a_{\ell}-\mu_{\ell})=\mathrm{MD}_{\Sigma_{\ell}}\!\big{(}a_{\ell},\;W_{\ell}a_{\ell-1}+b_{\ell}\big{)}^{2},$ (46) $$

i.e., the squared Mahalanobis distance to the *conditional* mean with covariance $\Sigma_{\ell}$. In contrast, the classwise (unconditional) Mahalanobis score at layer $\ell$ typically uses means $\{\bar{\mu}_{\ell,c}\}$ and (shared) covariance $\bar{\Sigma}_{\ell}$, yielding $\min_{c}(a_{\ell}-\bar{\mu}_{\ell,c})^{\top}\bar{\Sigma}_{\ell}^{-1}(a_{\ell}-\bar{\mu}_{\ell,c})$. Unless $W_{\ell}a_{\ell-1}+b_{\ell}=\bar{\mu}_{\ell,c^{\star}}$ for some class $c^{\star}$ (a strong condition), the unconditional score conflates between-class variation with dynamics-induced shift. Therefore, SNAP-UQ’s $e_{\ell}$ captures deviations from depth-wise *transformations* rather than deviations from class centroids, which explains its sensitivity to distribution shift that perturbs inter-layer mappings. ∎

### H.4 Proof of Proposition 2.3 (Affine invariance for BN-like rescaling)

Consider a per-channel affine transformation of activations $a_{\ell}^{\prime}=s\odot a_{\ell}+t$ with $s>0$ and the co-adapted predictor outputs $\mu_{\ell}^{\prime}=s\odot\mu_{\ell}+t$ and $\sigma_{\ell}^{\prime}=s\odot\sigma_{\ell}$ (these transformations are consistent with batch-normalization statistics). Then

$$ $\displaystyle e_{\ell}^{\prime}(x)$ $\displaystyle=\big{\|}(a_{\ell}^{\prime}-\mu_{\ell}^{\prime})\odot(\sigma_{\ell}^{\prime})^{-1}\big{\|}_{2}^{2}=\big{\|}(s\odot a_{\ell}+t-s\odot\mu_{\ell}-t)\odot(s\odot\sigma_{\ell})^{-1}\big{\|}_{2}^{2}$ (47) $\displaystyle=\big{\|}s\odot(a_{\ell}-\mu_{\ell})\odot(s^{-1}\odot\sigma_{\ell}^{-1})\big{\|}_{2}^{2}=\big{\|}(a_{\ell}-\mu_{\ell})\odot\sigma_{\ell}^{-1}\big{\|}_{2}^{2}=e_{\ell}(x).$ (48) $$

Thus $e_{\ell}$ (and hence $S$) is invariant to such per-channel affine rescalings at optimum. ∎

### H.5 Distributional calibration under the model

If the conditional model is well specified with diagonal $\Sigma_{\ell}$, then $e_{\ell}(x)=\sum_{i=1}^{d_{\ell}}\big{(}\tfrac{a_{\ell,i}-\mu_{\ell,i}}{\sigma_{\ell,i}}\big{)}^{2}\sim\chi^{2}_{d_{\ell}}$. Hence

$$ $\mathbb{E}\big{[}\bar{e}_{\ell}\big{]}=1,\qquad\mathrm{Var}\big{[}\bar{e}_{\ell}\big{]}=\tfrac{2}{d_{\ell}}.$ (49) $$

This implies a simple sanity-check: on clean ID data, $\bar{e}_{\ell}$ should concentrate near $1$; persistent elevation indicates mismatch or shift. For low-rank-plus-diagonal $\Sigma_{\ell}$ (Appx [I](https://arxiv.org/html/2508.12907v1#A9)), $e_{\ell}$ follows a (weighted) generalized $\chi^{2}$; bounds follow from eigenvalue inequalities of $\Sigma_{\ell}^{-1}$.

### H.6 Student- t t and Huberized variants

For the Student-$t$ variant with dof $\nu_{\ell}>0$ and diagonal scales $\sigma_{\ell}$,

$$ $-\log p(a_{\ell}\mid a_{\ell-1})=\sum_{i=1}^{d_{\ell}}\tfrac{\nu_{\ell}+1}{2}\log\!\Big{(}1+\tfrac{(a_{\ell,i}-\mu_{\ell,i})^{2}}{\nu_{\ell}\sigma_{\ell,i}^{2}}\Big{)}+\tfrac{1}{2}\log\sigma_{\ell,i}^{2}+\text{const}(\nu_{\ell}),$ (50) $$

which produces Eq. equation [6](https://arxiv.org/html/2508.12907v1#S2.E6). As $\nu_{\ell}\!\to\!\infty$, this reduces to the Gaussian NLL. The Huberized variant in Eq. equation [7](https://arxiv.org/html/2508.12907v1#S2.E7) is the Gaussian NLL with the quadratic term replaced by $\rho_{\delta}(u)=\tfrac{1}{2}u^{2}\mathbb{I}(|u|\leq\delta)+(\delta|u|-\tfrac{1}{2}\delta^{2})\mathbb{I}(|u|>\delta)$, improving robustness to occasional heavy-tailed channels.

## Appendix I Low-rank-plus-diagonal covariance: Woodbury identities

Let $\Sigma_{\ell}=D_{\ell}+B_{\ell}B_{\ell}^{\top}$ with $D_{\ell}=\mathrm{diag}(\sigma_{\ell}^{2})\succ 0$ and $B_{\ell}\in\mathbb{R}^{d_{\ell}\times k_{\ell}}$, $k_{\ell}\ll d_{\ell}$. Using the matrix determinant lemma and Woodbury identity:

#### Log-determinant.

$$ $\displaystyle\log\det\Sigma_{\ell}$ $\displaystyle=\log\det(D_{\ell})\;+\;\log\det\!\big{(}I_{k_{\ell}}+B_{\ell}^{\top}D_{\ell}^{-1}B_{\ell}\big{)}.$ (51) $$

#### Quadratic form.

For $v_{\ell}=a_{\ell}-\mu_{\ell}$,

$$ $\displaystyle\Sigma_{\ell}^{-1}$ $\displaystyle=D_{\ell}^{-1}-D_{\ell}^{-1}B_{\ell}\big{(}I_{k_{\ell}}+B_{\ell}^{\top}D_{\ell}^{-1}B_{\ell}\big{)}^{-1}B_{\ell}^{\top}D_{\ell}^{-1},$ (52) $\displaystyle v_{\ell}^{\top}\Sigma_{\ell}^{-1}v_{\ell}$ $\displaystyle=\underbrace{v_{\ell}^{\top}D_{\ell}^{-1}v_{\ell}}_{e_{\ell}^{\text{diag}}}\;-\;\underbrace{\|(I_{k_{\ell}}+B_{\ell}^{\top}D_{\ell}^{-1}B_{\ell})^{-1/2}B_{\ell}^{\top}D_{\ell}^{-1}v_{\ell}\|_{2}^{2}}_{\Delta_{\ell}}.$ (53) $$

Thus the low-rank correction subtracts a nonnegative term $\Delta_{\ell}$, tightening the diagonal model. Computationally: (i) form $M_{\ell}=B_{\ell}^{\top}D_{\ell}^{-1}B_{\ell}\in\mathbb{R}^{k_{\ell}\times k_{\ell}}$; (ii) solve $(I+M_{\ell})^{-1}u$ for a few right-hand sides using Cholesky; cost is $O(d_{\ell}k_{\ell}+k_{\ell}^{3})$ per example. Both equation [51](https://arxiv.org/html/2508.12907v1#A9.E51) and equation [53](https://arxiv.org/html/2508.12907v1#A9.E53) are integer-friendly if $D_{\ell}^{-1}$ is implemented via per-channel scales.

#### NLL expression.

Putting terms together,

$$ $-\log p(a_{\ell}\mid a_{\ell-1})=\tfrac{1}{2}\Big{[}e_{\ell}^{\text{diag}}-\Delta_{\ell}+\log\det D_{\ell}+\log\det(I+M_{\ell})+d_{\ell}\log(2\pi)\Big{]}.$ (54) $$

When $k_{\ell}=0$ we recover the diagonal case.

## Appendix J Isotonic calibration details

We optionally replace the logistic mapping in Eq. equation [11](https://arxiv.org/html/2508.12907v1#S2.E11) by isotonic regression to obtain a nonparametric, monotone calibration from $(S,m)$ to error probability.

#### Feature construction.

Let $\psi(x)$ be either $\psi_{1}(x)=S(x)$ or $\psi_{2}(x)=(\gamma S(x)+(1-\gamma)m(x))$ with $\gamma\in[0,1]$ tuned on a validation split.

#### Fitting.

Given a development set $\{(\psi_{i},y_{i})\}_{i=1}^{n}$ with labels $y_{i}\in\{0,1\}$ indicating correctness, we solve the pool-adjacent-violators (PAV) problem:

$$ $\hat{f}\in\arg\min_{f\ \text{nondecreasing}}\sum_{i=1}^{n}(y_{i}-f(\psi_{i}))^{2}.$ (55) $$

The solution is a right-continuous, piecewise-constant function with at most $n$ steps and can be evaluated with binary search. We clip $\hat{f}$ to $[\epsilon,1-\epsilon]$ (e.g., $\epsilon=10^{-4}$) to avoid degenerate thresholds.

#### Deployment.

At inference, $U(x):=\hat{f}(\psi(x))$ replaces the logistic output; thresholds $\tau$ or budgeted risk controllers act on $U(x)$ identically. Isotonic guarantees that increasing $S$ (or the blend) never decreases the estimated error probability, which often sharpens risk–coverage under tight budgets.

## Appendix K Budgeted abstention controller

For applications with an abstention budget $b\in(0,1)$, we implement a simple controller that adapts the threshold $\tau$ to respect the long-run budget. Let $A_{t}=\mathbb{I}[U(x_{t})\geq\tau_{t}]$ and define an exponentially-weighted moving average (EWMA) $\bar{A}_{t}=\eta A_{t}+(1-\eta)\bar{A}_{t-1}$ ($\bar{A}_{0}=0$, $\eta\in(0,1]$). We update

$$ $\tau_{t+1}\leftarrow\tau_{t}+\kappa\,(\bar{A}_{t}-b),$ (56) $$

with a small step $\kappa>0$. Intuitively, if recent abstentions exceed $b$, the threshold increases; otherwise it decreases. This keeps the abstention fraction near $b$ while responding to bursts of high uncertainty. The controller is scalar, requires no labels, and adds negligible overhead.

## Appendix L Additional complexity accounting

For a conv layer with $C_{\text{in}}\!\times\!H\!\times\!W$ input and $C_{\text{out}}\!\times\!H^{\prime}\!\times\!W^{\prime}$ output, choosing $P_{\ell}$ as a $1{\times}1$ pointwise projection from $C_{\text{in}}\to r_{\ell}$ followed by global average pooling costs $HWr_{\ell}+r_{\ell}$ multiply–adds. Two linear heads mapping $r_{\ell}\to d_{\ell}=C_{\text{out}}$ cost $2r_{\ell}d_{\ell}$. Summed across $|\mathcal{S}|$ taps, the overall fraction of backbone FLOPs is

$$ $\textstyle\rho\approx\frac{\sum_{\ell\in\mathcal{S}}(H_{\ell}W_{\ell}r_{\ell}+2r_{\ell}d_{\ell})}{\text{FLOPs(backbone)}},$ (57) $$

which is typically $<2\%$ in our TinyML settings for $r_{\ell}\in[32,128]$ and $|\mathcal{S}|\leq 3$.

## Appendix M Implementation notes for integer inference

We quantize $P_{\ell},W_{\mu,\ell},W_{\sigma,\ell}$ to int8 with per-tensor scales $s_{P},s_{\mu},s_{\sigma}$. Let $\tilde{z}_{\ell}=\mathrm{round}(z_{\ell}/s_{z})$ be int8 and similarly for weights; accumulations are in int32. For standardized error, we compute

$$ $\bar{e}_{\ell}=\tfrac{1}{d_{\ell}}\sum_{i}\big{(}(a_{\ell,i}-\mu_{\ell,i})\,\tilde{s}_{\sigma,i}\big{)}^{2},$ (58) $$

where $\tilde{s}_{\sigma,i}\approx\exp(-\tfrac{1}{2}\log\sigma_{\ell,i}^{2})$ is looked up from a $256$-entry LUT indexed by quantized $\log\sigma_{\ell,i}^{2}$; this avoids runtime exponentials while preserving monotonicity. Clamping $\log\sigma_{\ell,i}^{2}\in[\log\sigma_{\min}^{2},\log\sigma_{\max}^{2}]$ guarantees bounded dynamic range.

Summary.
Propositions [2.1](https://arxiv.org/html/2508.12907v1#S2.Thmproposition1)–[2.3](https://arxiv.org/html/2508.12907v1#S2.Thmproposition3) formalize that SNAP-UQ’s score $S(x)$ is (i) an affine transform of the depth-wise NLL under a simple conditional model, (ii) a Mahalanobis energy to the *conditional* mean that is sensitive to shifts in inter-layer dynamics, and (iii) invariant to BN-like rescalings. The Woodbury derivations provide efficient low-rank covariance handling, and isotonic calibration gives a monotone, nonparametric mapping for budgeted selective prediction.

## Appendix N Ablations and Sensitivity Analyses

This section expands on design choices for *SNAP-UQ*: tap placement, projector rank, quantization of heads, uncertainty mapping, risk–coverage behavior, calibration reliability, and corruption/error clusters. Unless noted, results are averaged over three seeds; error bars denote 95% CIs from 1,000$\times$ bootstrap.

### N.1 Tap placement and projector rank

We vary (i) the set of tapped layers $\mathcal{S}$ and (ii) projector rank $r_{\ell}$. Taps are chosen at the end of a *mid* block (M) and/or the *penultimate* block (P). As shown in [Table 5](https://arxiv.org/html/2508.12907v1#A14.T5), two taps (M+P) consistently provide the best accuracy–latency trade-off on both CIFAR-10 (Big-MCU) and SpeechCmd (Small-MCU). The trend with rank is visualized in [Figure 3](https://arxiv.org/html/2508.12907v1#A14.F3), where AUPRC improves as $r$ increases while latency remains nearly flat.

**Table 5: Taps and projector rank. CIFAR-10/Big-MCU (top) and SpeechCmd/Small-MCU (bottom). Latency in ms. AUROC is ID$\checkmark$ — ID$\times$; AUPRC is accuracy-drop (avg over -C).**
| CIFAR-10 (Big-MCU) |  |  |  |  |
| --- | --- | --- | --- | --- |
| Config | Flash (KB) | Lat. (ms) | AUROC $\uparrow$ | AUPRC $\uparrow$ |
| P only, $r{=}32$ | 276 | 88 | 0.83 | 0.62 |
| P only, $r{=}64$ | 284 | 86 | 0.84 | 0.64 |
| M+P, $r{=}64$ | 292 | 83 | 0.86 | 0.70 |
| M+P, $r{=}128$ | 306 | 86 | 0.87 | 0.72 |
| M+P+early, $r{=}64$ | 315 | 90 | 0.86 | 0.71 |
| SpeechCmd (Small-MCU) |  |  |  |  |
| Config | Flash (KB) | Lat. (ms) | AUROC $\uparrow$ | AUPRC $\uparrow$ |
| P only, $r{=}32$ | 114 | 118 | 0.92 | 0.62 |
| P only, $r{=}64$ | 116 | 116 | 0.93 | 0.63 |
| M+P, $r{=}64$ | 118 | 113 | 0.94 | 0.65 |
| M+P, $r{=}96$ | 121 | 115 | 0.94 | 0.66 |

Figure: Figure 3: Rank sensitivity. Accuracy-drop improves with rank; latency impact is small (CIFAR-10/Big-MCU).

#### Takeaway.

Two taps (mid+penultimate) provide the best accuracy–latency trade-off ([Table 5](https://arxiv.org/html/2508.12907v1#A14.T5)); increasing rank beyond 64 yields diminishing returns with small latency changes ([Figure 3](https://arxiv.org/html/2508.12907v1#A14.F3)).

### N.2 Quantization of SNAP heads

We compare float32, float16, and int8 for the projector and predictor heads while keeping the backbone unchanged. [Table 6](https://arxiv.org/html/2508.12907v1#A14.T6) shows that int8 preserves AUPRC within the CI while reducing flash and improving latency.

**Table 6: Quantization variants. Heads only (projectors + $(\mu,\log\sigma^{2})$). CIFAR-10/Big-MCU and SpeechCmd/Small-MCU.**
| Precision | CIFAR-10 (Big-MCU) |  | SpeechCmd (Small-MCU) |  |  |
| --- | --- | --- | --- | --- | --- |
| Flash (KB) | AUPRC $\uparrow$ |  | Flash (KB) | AUPRC $\uparrow$ |  |
| FP32 | 324 | 0.71 |  | 128 | 0.66 |
| FP16 | 306 | 0.71 |  | 122 | 0.66 |
| INT8 | 292 | 0.70 |  | 118 | 0.65 |

#### Takeaway.

INT8 preserves performance while cutting flash by $1.6$–$2.1\times$ and lowering latency by 7–9% ([Table 6](https://arxiv.org/html/2508.12907v1#A14.T6)).

### N.3 Mapping alternatives: logistic vs. isotonic

We compare the 3-parameter logistic map with isotonic regression. As summarized in [Table 7](https://arxiv.org/html/2508.12907v1#A14.T7), isotonic yields consistently lower risk at fixed coverage; the full risk–coverage curves in [Figure 4](https://arxiv.org/html/2508.12907v1#A14.F4) show the gap across operating points.

**Table 7: Risk at fixed coverage. Lower is better (CIFAR-10-C).**
| Method | Risk @ 80% | Risk @ 90% | Risk @ 95% |
| --- | --- | --- | --- |
| Logistic (SNAP) | 0.136 | 0.109 | 0.098 |
| Isotonic (SNAP) | 0.127 | 0.104 | 0.096 |
| Entropy (baseline) | 0.154 | 0.124 | 0.112 |

Figure: Figure 4: Risk–coverage (CIFAR-10-C). Isotonic improves budgeted operation.

### N.4 Risk–coverage across datasets

The advantage of SNAP holds beyond CIFAR-10; [Figure 5](https://arxiv.org/html/2508.12907v1#A14.F5) shows lower risk at matched coverage on MNIST-C and SpeechCmd-C.

Figure: Figure 5: Risk–coverage on two datasets (lower is better). SNAP dominates at moderate to high coverage.

### N.5 Reliability diagrams (ID)

We plot accuracy vs. confidence using 15 adaptive bins. Points in [Figure 6](https://arxiv.org/html/2508.12907v1#A14.F6) lie close to the diagonal on MNIST and CIFAR-10, indicating well-behaved calibration on ID data.

Figure: Figure 6: Reliability diagrams (SNAP-UQ). Points near the diagonal indicate good calibration; overconfidence would fall below the dashed line.

### N.6 Error/corruption clusters and abstention

We analyze the most frequent CID failures and report abstention rates at a tuned operating point (90% recall on event frames). [Table 8](https://arxiv.org/html/2508.12907v1#A14.T8) lists the top clusters on CIFAR-10-C (sev. 4–5), and [Figure 7](https://arxiv.org/html/2508.12907v1#A14.F7) visualizes the gap to baselines.

**Table 8: Top failure clusters (CIFAR-10-C, severity 4–5). Abstention rate among misclassified frames.**
| Cluster | SNAP-UQ (%) | EE-ens (%) | DEEP (%) |
| --- | --- | --- | --- |
| Motion blur | 72.4 | 58.9 | 61.2 |
| Contrast | 68.1 | 53.4 | 56.7 |
| JPEG | 63.9 | 49.2 | 51.6 |
| Snow | 59.7 | 47.1 | 50.3 |
| Frost | 58.3 | 45.0 | 47.6 |

Figure: Figure 7: Abstention on hard clusters (CIFAR-10-C, sev. 4–5). SNAP-UQ defers more often on the most failure-prone corruptions.

### N.7 Tap removal (leave-one-out)

We remove one tap at a time (with $r{=}64$) on CIFAR-10/Big-MCU. As summarized in [Table 9](https://arxiv.org/html/2508.12907v1#A14.T9), both taps contribute, with the mid-block tap providing most of the CID-detection gain.

**Table 9: Leave-one-out taps (CIFAR-10, M+P baseline).**
| Variant | Lat. (ms) | AUROC $\uparrow$ | AUPRC $\uparrow$ |
| --- | --- | --- | --- |
| SNAP (M+P) | 83 | 0.86 | 0.70 |
| w/o M | 86 | 0.84 | 0.66 |
| w/o P | 85 | 0.83 | 0.64 |

### N.8 Optional confidence blend

Adding the blend term $m(x)$ (from max-probability/margin) to the logistic improves separation on hard ID/CID cases with no runtime cost. [Table 10](https://arxiv.org/html/2508.12907v1#A14.T10) reports SpeechCmd gains.

**Table 10: Blend ablation (SpeechCmd).**
| Config | AUROC (ID$\checkmark$ — ID$\times$) $\uparrow$ | AUPRC (C) $\uparrow$ |
| --- | --- | --- |
| $U=\sigma(\beta_{0}+\beta_{1}S)$ (no blend) | 0.93 | 0.64 |
| $+\;m(x)$, $\beta_{2}>0$ (default) | 0.94 | 0.65 |

## Appendix O Extended Comparative Scope and Single-Pass Head-to-Head

This appendix expands the comparative scope for *single-pass* uncertainty/OOD baselines and reports head-to-head results under the same MCU deployment and tuning protocol as SNAP-UQ. We focus on methods that (i) need no extra forward passes, (ii) keep no temporal state, and (iii) fit the same INT8 budget. Summary results appear in Tables [11](https://arxiv.org/html/2508.12907v1#A15.T11), [13](https://arxiv.org/html/2508.12907v1#A15.T13) and [15](https://arxiv.org/html/2508.12907v1#A15.T15), with risk–coverage curves in Figs. [8](https://arxiv.org/html/2508.12907v1#A15.F8) and [9](https://arxiv.org/html/2508.12907v1#A15.F9) and clean-ID FPR in Tables [12](https://arxiv.org/html/2508.12907v1#A15.T12) and [14](https://arxiv.org/html/2508.12907v1#A15.T14).

### O.1 Methods considered and deployment parity

MSP/Entropy (max posterior, predictive entropy);
Temperature scaling (ID dev only);
Energy $\mathrm{logsumexp}(g(a_{D})/T)$ with $T$ tuned on dev;
Mahalanobis@taps (classwise means + diagonal covariances at the same tapped layers as SNAP-UQ; score is min diagonal Mahalanobis);
ReAct (Sun et al., 2021) (percentile clipping of tapped activations with per-channel thresholds fixed on dev);
ASH (Djurisic et al., 2023) (activation shaping via percentile shrinkage at one tap).
On Big-MCU only, we additionally report ODIN-lite (temperature scaling without input perturbation) and MC Dropout / Deep Ensembles when they fit; non-fitting methods are marked *OOM* and excluded from runtime summaries.
All baselines are evaluated under identical quantization/runtime conditions; see the head-to-head results in Tables [11](https://arxiv.org/html/2508.12907v1#A15.T11) and [13](https://arxiv.org/html/2508.12907v1#A15.T13) and the corresponding curves in Figs. [8](https://arxiv.org/html/2508.12907v1#A15.F8) and [9](https://arxiv.org/html/2508.12907v1#A15.F9).

### O.2 Decision-centric protocol and metrics

Beyond AUROC/AUPRC, we surface decision metrics useful on-device:
(i) Risk at fixed coverage (80/90/95%) on CID streams (lower is better; reported in Tables [11](https://arxiv.org/html/2508.12907v1#A15.T11) and [13](https://arxiv.org/html/2508.12907v1#A15.T13), and visualized in Figs. [8](https://arxiv.org/html/2508.12907v1#A15.F8) and [9](https://arxiv.org/html/2508.12907v1#A15.F9));
(ii) AURC (area under the risk–coverage curve; Tables [11](https://arxiv.org/html/2508.12907v1#A15.T11), [13](https://arxiv.org/html/2508.12907v1#A15.T13));
(iii) Selective NLL conditioned on accepted samples at 90% coverage (Table [15](https://arxiv.org/html/2508.12907v1#A15.T15));
(iv) Clean-ID FPR at matched 90% recall on event frames (Tables [12](https://arxiv.org/html/2508.12907v1#A15.T12), [14](https://arxiv.org/html/2508.12907v1#A15.T14)).
For each method, the operating threshold is chosen *once* on a dev stream and then held fixed for test streams.

### O.3 Head-to-head: CIFAR-10-C (streaming)

SNAP-UQ yields the lowest risk at 80/90/95% coverage and the smallest AURC in the single-pass family (Table [11](https://arxiv.org/html/2508.12907v1#A15.T11)); the full risk–coverage traces are shown in Fig. [8](https://arxiv.org/html/2508.12907v1#A15.F8). At matched 90% event recall, SNAP-UQ also achieves the lowest clean-ID FPR (Table [12](https://arxiv.org/html/2508.12907v1#A15.T12)).

**Table 11: Single-pass head-to-head on CIFAR-10-C streams. Risk at fixed coverage (lower is better) and AURC. Thresholds fixed on dev and reused for test.**
| Method | Risk@80% $\downarrow$ | Risk@90% $\downarrow$ | Risk@95% $\downarrow$ | AURC $\downarrow$ |
| --- | --- | --- | --- | --- |
| MSP / Entropy | 0.154 | 0.124 | 0.112 | 0.118 |
| Energy ($T$) | 0.148 | 0.117 | 0.106 | 0.112 |
| Mahalanobis@taps | 0.141 | 0.113 | 0.102 | 0.109 |
| ReAct | 0.139 | 0.111 | 0.101 | 0.107 |
| ASH | 0.138 | 0.110 | 0.100 | 0.106 |
| SNAP-UQ | 0.127 | 0.104 | 0.096 | 0.099 |

Figure: Figure 8: Risk–coverage on CIFAR-10-C. Lower is better; compare with Table [11](https://arxiv.org/html/2508.12907v1#A15.T11) for numeric points.

**Table 12: Clean-ID false-positive rate at matched 90% recall on event frames (CIFAR-10-C streams).**
| Method | FPR on clean ID $\downarrow$ | Notes |
| --- | --- | --- |
| MSP / Entropy | 0.079 | threshold fixed on dev |
| DEEP (Big-MCU) | 0.065 | single-pass comparison not applicable on Small-MCU |
| EE-ens (Big-MCU) | 0.079 | single-pass comparison not applicable on Small-MCU |
| SNAP-UQ | 0.042 | same dev threshold, one pass |

### O.4 Head-to-head: SpeechCommands-C (streaming)

On SpeechCmd-C, SNAP-UQ again achieves the best risk at 80/90/95% coverage and the lowest AURC (Table [13](https://arxiv.org/html/2508.12907v1#A15.T13)); the risk–coverage curves are shown in Fig. [9](https://arxiv.org/html/2508.12907v1#A15.F9). Clean-ID FPR at matched recall is summarized in Table [14](https://arxiv.org/html/2508.12907v1#A15.T14).

**Table 13: Single-pass head-to-head on SpeechCmd-C streams. Risk at fixed coverage and AURC.**
| Method | Risk@80% $\downarrow$ | Risk@90% $\downarrow$ | Risk@95% $\downarrow$ | AURC $\downarrow$ |
| --- | --- | --- | --- | --- |
| MSP / Entropy | 0.118 | 0.072 | 0.063 | 0.091 |
| Energy ($T$) | 0.112 | 0.067 | 0.059 | 0.087 |
| Mahalanobis@taps | 0.106 | 0.064 | 0.056 | 0.084 |
| ReAct | 0.104 | 0.062 | 0.055 | 0.083 |
| ASH | 0.103 | 0.061 | 0.054 | 0.082 |
| SNAP-UQ | 0.100 | 0.058 | 0.051 | 0.081 |

Figure: Figure 9: Risk–coverage on SpeechCmd-C. Lower is better; the numeric points at 80/90/95% correspond to Table [13](https://arxiv.org/html/2508.12907v1#A15.T13).

**Table 14: Clean-ID false-positive rate at matched 90% recall on event frames (SpeechCmd-C streams).**
| Method | FPR on clean ID $\downarrow$ | Notes |
| --- | --- | --- |
| MSP / Entropy | 0.064 | threshold fixed on dev |
| Energy ($T$) | 0.060 |  |
| Mahalanobis@taps | 0.057 |  |
| SNAP-UQ | 0.031 | one pass, same dev threshold |

### O.5 Selective NLL at 90% coverage

Consistent with the risk–coverage results (Tables [11](https://arxiv.org/html/2508.12907v1#A15.T11) and [13](https://arxiv.org/html/2508.12907v1#A15.T13)), SNAP-UQ attains the lowest selective NLL at 90% coverage on both datasets (Table [15](https://arxiv.org/html/2508.12907v1#A15.T15)).

**Table 15: Selective NLL conditioned on accepted samples at 90% coverage (lower is better).**
| Method | CIFAR-10-C $\downarrow$ | SpeechCmd-C $\downarrow$ |
| --- | --- | --- |
| MSP / Entropy | 0.368 | 0.226 |
| Energy ($T$) | 0.357 | 0.214 |
| Mahalanobis@taps | 0.349 | 0.208 |
| ReAct | 0.346 | 0.206 |
| ASH | 0.344 | 0.205 |
| SNAP-UQ | 0.339 | 0.182 |

### O.6 Reproducibility checklist (this section)

For completeness, we summarize the exact protocol that underlies Tables [11](https://arxiv.org/html/2508.12907v1#A15.T11)–[15](https://arxiv.org/html/2508.12907v1#A15.T15) and Figs. [8](https://arxiv.org/html/2508.12907v1#A15.F8)–[9](https://arxiv.org/html/2508.12907v1#A15.F9).

- •
*Dev/test split:* a single dev stream per dataset (ID $\rightarrow$ CID $\rightarrow$ OOD) for threshold/temperature/percentile selection; test streams share the same composition but disjoint seeds.
- •
*Quantization:* INT8 weights per tensor; FP16 accumulators as needed; identical to section [3](https://arxiv.org/html/2508.12907v1#S3).
- •
*Runtime:* cycle‐counter timing, 1,000 inferences averaged; interrupts masked; datasheet nominal clock.
- •
*Risk–coverage:* coverage levels computed on test streams with the *dev-fixed* threshold; AURC by trapezoidal rule (as in Tables [11](https://arxiv.org/html/2508.12907v1#A15.T11), [13](https://arxiv.org/html/2508.12907v1#A15.T13) and Figs. [8](https://arxiv.org/html/2508.12907v1#A15.F8), [9](https://arxiv.org/html/2508.12907v1#A15.F9)).
- •
*FPR at matched recall:* event recall target 90% set on dev; FPR measured on clean ID segments of test streams (Tables [12](https://arxiv.org/html/2508.12907v1#A15.T12), [14](https://arxiv.org/html/2508.12907v1#A15.T14)).

## Peer Reviews

confidence: 2
contribution: 3
initial_rating: 4
presentation: 2
questions: - What are fundamental advantages of the proposed method over QUTE in paper [1] before? This question concerns both theoretial and empirical aspects.
- How significant does the projector type effect the performance of SNAP-UQ?
soundness: 3
strengths: - The concept of next-activation applied in a layer-wise manner is interesting and demonstrates strong empirical performance.
- The proposed lightweight architecture achieves impressive results despite its extremely compact size (on the order of kilobytes).
- The effectiveness of the approach is validated across multiple tasks using practical evaluation metrics and reasonable baselines, yielding consistently encouraging results.
summary: This paper addresses the problem of estimating prediction uncertainty in neural networks, with a particular focus on TinyML applications. The topic is especially relevant for edge-device deployment, where input distributions may shift after training. The authors propose a novel lightweight architecture that attaches to selected layers of a backbone network to estimate uncertainty for each prediction. This tiny module predicts the next activation in a layer-wise manner, enabling the computation of a surprisal score. The method is evaluated on both vision and audio tasks using several baseline models. Experimental results show that the proposed approach preserves task accuracy while substantially reducing flash memory usage and inference latency, demonstrating its strong practical value.
weaknesses: - Despite its potential significance, the paper’s writing quality is problematic. It appears to have been heavily compressed—possibly with assistance from LLMs—resulting in missing definitions for key terms and notations (e.g., LUT, BN, ID$\surd$-ID$\times$, ID$\surd$-OOD, $1\times 1$ projector, ...). Some paragraphs even consist of a single sentence, making the paper difficult to follow.
- Although a theoretical analysis is included, it lacks sufficient discussion of its implications. The authors should provide interpretations that link their theoretical results to practical insights, and possibly include experiments to verify the claims, such as empirically testing Proposition 2.3.
- The comparative baselines appear outdated, raising concerns about the competitiveness of the proposed method. More recent approaches (e.g., [1]) should be discussed and included in the comparisons to strengthen the evaluation.

Reference:

[1] Ghanathe, N. P., & Wilton, S. J. QUTE: Quantifying Uncertainty in TinyML models with Early-exit-assisted ensembles for model-monitoring. In Forty-second International Conference on Machine Learning, 2025.

[2] Ahmed, S. T., Hefenbrock, M., & Tahoori, M. B. (2024). Tiny Deep Ensemble: Uncertainty Estimation in Edge AI Accelerators via Ensembling Normalization Layers with Shared Weights. The 43rd IEEE/ACM International Conference on Computer-Aided Design.

---

confidence: 3
contribution: 4
initial_rating: 8
presentation: 3
questions: - The proposed pipeline has a lot of steps, one being probability calibration with platt scaling, did you test if this step is necessary? What about using the raw score in Eq 9 as an uncertainty metric (I know its not a probability).
soundness: 4
strengths: - The paper is mostly well written and clear.
- Uncertainty in TinyML is an important open problem, there are not many papers in this area, so a new method and new state of the art are welcome.
- I believe the idea of predicting layer activations to produce uncertainty makes sense, this connects with previous ideas in the field like depth uncertainty and early exit ensembles. And the proposed method is specifically designed for TinyMl applications, which I believe is novel and significant.
- The evaluation is mostly good, there is a good selection of datasets, baselines, metrics, and microcontrollers platforms,
- Overall the conclusions are robust, that SNAP-UQ works best or is very competitive in terms of calibration, OOD detection and misclassification detection, producing a new state of the art for uncertainty estimation in TinyML.
- There is a good amount of appendices with relevant details and proofs of the proposed method being similar to existing methods, strengthening the proposed method and its usability.
summary: This paper is about uncertainty estimation in the context of Tiny ML, in particular this paper proposes an uncertainty estimation method based on predicting activations of some intermediate layers, from where an uncertainty score can be produced and transformed into a probability via platt scaling. This method is particularly designed for TinyML setups such as microcontrollers.

The contributions are:
- The SNAP-UQ method for uncertainty estimation in a TinyML context using a depth-wise surprisal signal.
- An MCU-ready implementation of the proposed method.
- Results for both ID and OOD detection performance on MNIST, CIFAR10, and SpeechCommands datasets showing the advantages of the proposed method.
weaknesses: - Some parts of the paper are hard to follow due to lots of mathematical notation, this is mostly in Sec 2.2 specifically at Eq 10 where the notation breaks. Overall I would recommend to the authors to try to minimize the necessary notation and to repeat the definitions of key notation in the paper, and try to explain concepts together with the math, this will make the paper much easier to understand and to implement.
- The paper claims results on TinyImageNet but the results are nowhere in the paper or the appendix, this weakens the claims slightly.
- The interesting ablation results are weak, by this I mean the hyperparameters that are relevant to the proposed method, which are presented in Appendix N, the authors showing the effect of the number of taps and the projector rank, but specifically for the number of taps only two taps are made, and I believe it would be interesting to try more taps and see if uncertainty improves.
- It would also have been interesting to try the huber and student's t-distributed variants, these are not explored in the experiments of this paper.
- In Table 1, to me it is not clear which model/method is denoted as "BASE", if its the baseline model without uncertainty estimation, I do not see how it could have higher latency and storage/RAM usage than when using SNAP-UQ, since SNAP-UQ slightly adds computation and memory use. Please clarify.
- In Figure 1, the definition of S(x) in the figure differs from Eq 9, the weights are missing.

---

confidence: 3
contribution: 2
initial_rating: 4
presentation: 3
questions: 1. **Could you provide reusable visualizations for tap selection?**: 
   Specifically, a surprisal correlation matrix among candidate layers (to show redundancy vs. distance), diminishing-return curves of performance versus the number of taps, and a leave-one-tap-out table. This would substantiate why two to three taps suffice and facilitate porting to new backbones.

2. **Could you report the datasets and tuning rules for Student-t and Huber?**: 
   Please specify the evaluated datasets, the grids for \nu and \delta, and the selection metrics. Include a comparison table (Gaussian vs. t vs. Huber) with AUROC/AUPRC, risk@coverage, AURC, FPR, recommended defaults (e.g., \nu=5, \delta=1.5), notes on stability (\nu fixed or learned; shared or per tap), and implications for INT8 implementation.

3. **Could you visualize the sources of the speedups?**: 
   Please add a stacked-bar breakdown of per-layer time, bandwidth, and temporary buffers for SNAP-UQ and the lightweight early-exit ensemble, with measurement conditions clearly stated, to clarify where the 25–35% latency difference arises.

4. **Could you promote the mapping choice to the main text and include a brief recipe?**: 
   For example, recommend isotonic for fixed-coverage monitoring and logistic when in-distribution calibration is the priority, and indicate whether combining S with a margin or confidence feature, m, is recommended by default.

5. **(Optional) Could you provide minimal-configuration guidance?**: 
   For extremely tight SRAM budgets or when intermediate activations are inaccessible, please include a small table for a minimal setup (e.g., pre-logits only, low rank such as r=32) showing latency, flash, and FPR trade-offs.
soundness: 3
strengths: The main strength is the shift from output layer confidence to violations of conditional layer to layer dynamics as the basis for uncertainty, captured in a single forward pass without labels, with only tens of kilobytes of added memory and about $2%$ extra MACs, making it suitable for MCUs. Light theoretical support, namely the equivalence to depthwise negative log likelihood and conditional Mahalanobis energy and scale invariance under batch normalization like rescaling, grounds the intuition that softmax confidence tends to degrade later, whereas inter layer dynamics deteriorate earlier. Empirically, the work is careful on deployment metrics (latency, flash, peak RAM, energy on device) and on decision centric metrics (AUPRC and detection delay under stream corruption, AUROC for ID correct versus ID error and ID correct versus OOD, risk coverage curves, FPR). The ablations, including leave one tap out, rank sensitivity with diminishing returns around $r\approx 64$, INT8 quantization, and logistic versus isotonic mapping, are directly useful to practitioners. Overall, while the theory is intentionally lightweight, the design is coherent and the practical benefits for TinyML monitoring are clear.
summary: This paper proposes SNAP-UQ, a single pass uncertainty estimation method for TinyML. The approach taps a small number of intermediate layers, predicts the mean and (diagonal or low rank + diagonal) variance of the next layer’s activations with a small INT8 head, and computes the standardized squared error (surprisal) between the prediction and the actual activation. Summing per layer surprisal yields a single pass uncertainty score $S(x)$, which is then converted to $U(x)\in[0,1]$ via a monotone mapper (logistic or isotonic) for monitoring and selective prediction. The authors argue that $S(x)$ is an affine transform of the depthwise negative log likelihood (a conditional Mahalanobis energy) and is invariant to batch normalization like channel rescalings. On real MCUs (Big and Small configurations), SNAP-UQ reduces latency, flash, RAM, and energy while improving corrupted stream detection (AUPRC and detection delay), failure detection (ID correct versus ID error, and ID correct versus OOD), and risk coverage. It is roughly 25 to 35% faster and 40 to 60% smaller than lightweight ensemble baselines, and continues to run where others run out of memory on Small MCU. The paper includes ablations on tap placement and rank, INT8 quantization, mapping choices, and head to head comparisons among single pass methods.
weaknesses: 1. **Tap placement feels ad-hoc.**:
Two taps (mid / pre-logits) seem to work—but moving to a new backbone still feels like guesswork. A tiny, illustrative check would help: a quick cross-layer correlation sketch to show how signal fades with distance, plus a short “one-tap-removed” table that makes redundancy visible.

2. **Where the latency gains come from is not entirely clear.**
While fairness is addressed, the source of the speedup is less so. Could you add a single stacked-bar breakdown—*backbone convolutions | tap projection/head | classifier | memory I/O*—and report the measurement conditions (fixed clock, CMSIS-NN, averaging protocol)? This would make the narrative clearer and explain why the advantage typically falls in the tens-of-percent range.

3. **Distributional variants (Student-t / Huber) aren’t yet actionable.**:
The math is there; the “when and how” is not. A small, concrete aid would do: a compact comparison on images and audio; a brief note on sensible defaults (e.g., workable (\nu) and (\delta) and the selection rule); and a line on stability (fix vs. learn (\nu), share across taps, INT8/LUT implications). With that, these variants become tools rather than curios.

**(Minor)** “Self-supervised” here refers to label-free auxiliary regression for uncertainty, not representation learning; a one-sentence clarification in the introduction would avoid confusion.

---

confidence: 2
contribution: 3
initial_rating: 6
presentation: 3
questions: - Can the proposed method be applied for larger-scale ML settings, such as ResNet-50 with ImageNet?
- In part 4.4, have the authors tried calibration on OOD data, such as on CIFAR-10-corrupted?
- In the experiments, the authors only show the accuracy drop or failure **detection** performance, but haven't shown what the actual accuracy drop or failure level actually is. Could the authors add accuracy results to Table 2 and Table 3?
soundness: 3
strengths: - The paper is well-written and solid, with a new method, theoretical, and empirical contributions.
- The proposed method is empirically deployed across audio and vision tasks, with significant improvement over early-exit and deep ensembles baselines in reducing flash and latency. 
- Beyond memory and latency improvement, it also improves accuracy-drop detection in corrupted streams by AUPRC and maintains strong failure detection with AUROC in a single pass.
summary: This work introduces SNAP-UQ, a single-pass, label-free uncertainty method for TinyML. SNAP-UQ maps a single forward pass depth-wise next-activation prediction, int8 heads uncertainty forecaster that drops neatly into CMSIS-NN pipelines and fits within kilobyte-scale MCU budgets. Results show SNAP-UQ improves accuracy-drop monitoring on corrupted streams, remains competitive on OOD failure detection, and strengthens ID calibration without temporal buffers, auxiliary exits, or extra passes.
weaknesses: - There is a computational limitation in training when compared to the standard cross-entropy loss. Specifically, the training objective requires jointly training with additional terms. It requires back-propagating with an additional label-free auxiliary loss and either a variance floor, scale control, or detach option loss.
- The experiments are reported with only three fixed seeds. The results are reported without variance.


Decision: Accept (Poster)