Depth-Staged SNR Curricula for Freshness-Aware Speech Inference at the Edge

A speech system on a vehicle or a sensor network has to trade two kinds of error against each other. Cleaning up a noisy recording takes computation, and computation takes time. By the time a heavily denoised command reaches the component that acts on it, the command may be out of date. Work on Age of Information (AoI), which measures how long ago the freshest delivered update was generated, has built good schedulers for this kind of timeliness. Those schedulers treat each update as a sealed packet whose usefulness depends only on its age. Speech research, in turn, has learned that models trained with a signal-to-noise ratio (SNR) curriculum, a schedule that moves from clean to noisy audio, train more stably. It has not asked how much of that model an edge device can afford to run before its output goes stale.

We propose to couple the two through the network's depth. Each curriculum stage gets its own block of layers and its own output head, called an exit. The shallow blocks learn on clean audio, and deeper blocks are added and trained only as the SNR drops. The trained model then has an explicit map from noise level to how much depth is needed. A freshness-aware scheduler can use that map to decide, for each update, whether to sample now and how deep to run. In two sentences: train a speech model whose curriculum stages become early-exit depths, so that the input's SNR tells you the cheapest depth that is still accurate. Then schedule updates with an index policy that minimizes task error as a joint function of age, SNR and depth, not age alone.

Core Claim

Our claim is that a depth-staged SNR curriculum produces exits whose error, as a function of input SNR, is predictable and ordered. Exits trained jointly on mixed noise conditions do not have this property. Predictability is what an AoI index scheduler needs to make good depth decisions. We expect the combination to lower time-averaged recognition error at the receiver, compared with two alternatives: always running the full model under a strong age-based scheduler, and confidence-thresholded early exits with no curriculum.

To make this concrete, let $a$ be the age of an update when it is delivered, $s$ the estimated SNR of the input, and $k$ the chosen exit depth. The exit depth adds a processing delay $d_k$, so a delivered update has age $a = d_k + \tau$, where $\tau$ is the queueing and transmission delay. The receiver's error then takes the form

$$e(a, s, k) = \epsilon_k(s) + g(a),$$

where $\epsilon_k(s)$ is exit $k$'s recognition error at SNR $s$, measured offline. The term $g(a)$ is the task penalty for stale information, for example the chance that a cabin command has already been overridden by a newer one. We measure $g$ from data and do not assume it is linear. The scheduler minimizes the long-run discounted sum of $e$ subject to a per-device compute or energy budget.

The additive form is a modelling assumption, and we will test it empirically. If $e$ turns out not to separate, the scheduler falls back to a table indexed by $(a, s, k)$ that is estimated directly from data.

Relation to Prior Work

The research file finds no paper that uses AoI to pace an SNR curriculum or that schedules denoising depth by age. The closest work falls into three groups, each playing a different role here.

The first group motivates the proposal by showing that staging by noise level helps. DESNet trains a multi-channel dereverberation, enhancement and separation network with staged SNR. Its authors note that the network is heavy and built for offline use. DyPCL paces dysarthric speech recognition from easy to hard phonetic contrasts and reports a 22.10% relative reduction in word error rate (WER). The top teams in the ICSRC in-cabin challenge relied on staged fine-tuning and front-end enhancement. All of these systems train a single fixed-depth model and treat the curriculum as a training aid that disappears at inference. We instead keep the curriculum's structure in the deployed network, as exits.

The second group supplies the scheduling method. Computation and Communication Co-scheduling for Timely Multi-Task Inference models task error as a function of AoI. It then uses Lagrangian relaxation, which turns the hard budget constraint into a price on resource use, to derive a Gain Index for each task. From that index it builds the Maximum Gain First (MGF) policy, which serves whichever task gains most from an update. It reports up to a 26x reduction in discounted error against Maximum Age First (MAF), the policy that always serves the oldest source. That paper assumes ideal channels and fixed pretrained models, with no choice of depth. We extend the index so that each decision also picks an exit, and we make error depend on input SNR.

Age-Based Scheduling for Mobile Edge Computing shows that local processing delay directly inflates age, and that minimizing latency is not the same as minimizing age. It treats workloads as raw bits with no link to what they are meant to recognize, which is exactly the gap we fill.

The third group constrains the design. Joint Status Sampling and Updating proves that zero-wait sampling, which samples again the moment a transmission finishes, is suboptimal under resource limits. The scheduler therefore has to be allowed to wait. Optimizing Age-of-Information in a Multi-class Queueing System shows that dropping updates when the server is busy (the M/G/1/1 discipline) prevents age from blowing up. This tells us to use single-slot buffers with replacement, not first-come-first-served queues. The Age-and-Value-Aware metric from Efficient Information Updates in Compute-First Networking shows the payoff of weighting age by the value of information, cutting update frequency by over 90%. Our SNR-dependent error term $\epsilon_k(s)$ is the speech-specific version of that value weighting.

Research Program

The first component is the depth-staged curriculum. We start from a compact Conformer, a speech recognition model that combines convolution and attention layers. It is pretrained on AISHELL-1, following the ICSRC baseline recipe. We split it into three or four blocks, each with its own recognition head trained with the CTC loss, a standard objective that does not need frame-level alignments.

Stage one trains block 1 and its exit on high-SNR in-cabin audio. Each later stage adds the next block and trains it on a lower SNR band. Earlier blocks are frozen or trained at a reduced learning rate, and their exits continue to be supervised on a replay of cleaner data so the curriculum does not erase clean-audio skills. Stage transitions are triggered by a plateau in held-out error at the current SNR band, not by a fixed step count. This responds to the known brittleness of hand-set curriculum boundaries.

From the trained model we measure $\epsilon_k(s)$ on held-out data and $d_k$ on a target edge CPU. A small auxiliary regressor estimates SNR from the features of block 1.

The second component is the scheduler. We extend MGF so that its index ranks joint decisions of the form "source $i$, exit $k$" by the expected error reduction per unit of shared resource, plus an option for each source to wait. We will prove that the extended index stays asymptotically optimal when sources are only weakly coupled, following the argument of the co-scheduling paper. Separately, we will quantify how errors in the SNR estimator degrade the policy.

Baselines

The naive reference point runs the full-depth model on every update, uses zero-wait sampling with a first-come-first-served queue, and uses a model trained with ordinary multi-condition training, meaning mixed SNRs with no staging. This is what a practitioner would deploy without thinking about freshness, and it sets the floor.

The strongest existing method is MGF from the co-scheduling paper. We run it with the same Conformer at full depth, an M/G/1/1 buffer, and an error function $g$ measured on the same data. It is the strongest competitor because it already optimizes task error, not raw age, and it beats MAF by up to 26x on the paper's synthetic benchmark. That paper reports no result for speech, SNR-varying inputs or ICSRC, and the file contains no reported result on Lacuna for any age-aware scheduler on ICSRC, so we will produce these numbers ourselves.

As an accuracy anchor for the recognizer, the ICSRC Track I winner reports 10.66% character error rate (CER) under 15M parameters, against a 53.57% Conformer baseline ICSRC. Our full-depth exit should land near that range before the scheduling comparison means anything.

We also run MAF, and a latency-minimizing scheduler to confirm the finding in Age-Based Scheduling for MEC.

Two ablations isolate the key ingredient. In the first, early exits are trained jointly on all SNRs with no curriculum and scheduled by the same extended index. This isolates the curriculum. In the second, the depth-staged model uses SNR-threshold exits but the scheduler ignores age. This isolates the scheduling.

All systems share the same data, the same backbone parameter count, the same arrival traces and the same edge-CPU latency profile. Each gets an equal hyperparameter search budget of 20 configurations on a validation trace.

Beating MGF means a statistically significant reduction in time-averaged receiver error at equal compute and energy budget, holding across at least three traffic loads. Beating the joint-exit ablation means the same reduction, with the gap largest at intermediate SNRs, where choosing the right depth matters most.

Why not just…?

Why not just use confidence-based early exits without any curriculum? This is the most serious threat. Exits trained jointly with a softmax-confidence stopping rule are standard and cheap. If their errors can be predicted from confidence as well as ours can from SNR, the curriculum adds nothing. The joint-exit ablation settles this directly. We will compare how well each model's exit error can be predicted by rank correlation between predicted and realized per-exit error across SNR bins, and we will compare the scheduling outcome. If the joint exits match on both, we will report that the gain comes from the scheduler alone and drop the curriculum claim.

Why not just denoise fully on the device, as DESNet does, and schedule with plain AoI? DESNet reaches a PESQ of 3.00 (a perceptual speech quality score) but is described as offline and heavy. Age-Based Scheduling for MEC shows that local processing delay feeds straight into age. The full-depth MGF baseline is exactly this design. Our experiments show where it loses: under high load and when commands change quickly, which is where $g$ is steep.

Why not just pick the exit from estimated SNR alone and ignore age? This works when the network is idle. When the network is congested it cannot trade a slightly worse transcript for a much fresher one. The SNR-only ablation measures this. We expect it to match our method at low load and fall behind as load rises. If it does not fall behind, the age term is not earning its place.

Proposed Experiments

We build an in-cabin simulation from the ICSRC 2022 dataset. Several sources share one edge link, each replaying ICSRC command utterances under a Poisson arrival process. Commands are grouped by category, and each category has its own penalty $g$ for staleness: a fixed-phrase air-conditioning command changes slowly, while a navigation (POI) or phone-call command changes quickly. The challenge itself reports that these categories differ, with CER of about 1.5% versus 12–21%. SNR varies through the recorded vehicle states, such as speed and whether windows are open, plus added cabin noise at controlled levels.

The primary metric is time-averaged receiver error, meaning the fraction of time the receiver acts on a wrong or superseded command. We also report per-exit CER, average and peak AoI, and energy per update. To test transfer to a different kind of difficulty, we repeat the curriculum-predictability measurement on UASpeech, using intelligibility level instead of SNR. There the reference is DyPCL's reduction in very-low-intelligibility WER from 58.49% to 49.45%.

Three results would be decisive. First, the curriculum exits must show lower error-prediction residuals than joint exits. Second, the full system must reduce receiver error against full-depth MGF at matched budget. Third, the separability test, comparing the additive model of $e$ with the direct $(a, s, k)$ table, must show whether the simple index is enough.

If the first check fails, the proposal reduces to depth-aware MGF, which is still a publishable extension but a smaller one.