Glossary

A

Acceptance rate

In self-speculative decoding, the fraction of tokens proposed by the shallow (draft) exit that full-depth verification accepts unchanged; a higher rate means more speculative work is reused instead of recomputed. On the 40-prompt AMI evaluation the off-the-shelf LayerSkip 1B ranges from 9.16% at exit 4 to 53.95% at exit 12 (greedy, N=40), and the held-out multi-exit adapter reaches 20.46% at exit 8 on its non-empty denominator (17.39% when the six empty generations are charged as failures).

Where used: src/training/eval_checkpoint_acceptance.sh, experiments/runs/2026-09-22T18-22-08Z-heldout-retrain/acceptance_heldout.md; see /experiments.

AdamW

The Adam optimizer with decoupled weight decay; it is the optimizer used for every LoRA training run in this project (torch.optim.AdamW, default learning rate 2e-4).

Where used: src/training/train_layerskip_lora.py; see /technology.

Adapter (LoRA)

A small set of trainable low-rank weight matrices attached to a frozen base model, so fine-tuning updates only the adapter. Trained adapters are saved as adapter-final and can be merged back into the base weights before evaluation.

Where used: src/training/train_layerskip_lora.py, src/training/merge_lora.py, experiments/runs/2026-09-22T18-22-08Z-heldout-retrain/adapter-final/; see /technology.

AMI corpus

The AMI Meeting Corpus (manual annotations 1.6.2): multi-party meeting recordings with word-level timing, used here as the proxy conversational source for pause statistics and for meeting-style training and evaluation text. It is a proxy for telephone dialogue, and the pause extractor carries that caveat explicitly.

Where used: experiments/runs/2026-09-21T19-05Z-test2-pause-durations/ami_pause_stats.json, src/training/ami_corpus.py, experiments/runs/2026-09-21T19-10Z-test3-acceptance/conv_eval_ami.jsonl; see /experiments.

AND gate (conjunctive trigger)

The trigger fires only when both signals clear their thresholds (p_end ≥ 0.75 and p_deep ≥ 0.65 by default), never either alone. This conservative, asymmetric design keeps a false trigger cheap — it costs only a discarded branch — and the unit tests guard against accidental OR-gate drift.

Where used: src/trigger_policy/policy.py, src/trigger_policy/test_policy.py, docs/02_HNIA_PADS_PRD.md; see /architecture.

Attention mask

The tensor that tells self-attention which positions each token may attend to. For a single unpadded sequence this project passes no mask and lets the library apply causal masking internally, because padding is never used in these single-sequence forwards.

Where used: src/pipeline/pads_pipeline.py (_embedded_inputs); see /technology.

Autoregressive decoding

Generating text one token at a time, where each new token is conditioned on all previous tokens. All generation measured here is autoregressive, capped at 128 tokens per prompt in the acceptance and baseline harnesses.

Where used: src/eval/benchmark_harness.py, src/pipeline/pads_pipeline.py; see /technology.

B

Baseline

A reference configuration measured with the same prompts, harness, and protocol as the method, so comparisons are like-for-like rather than cited from other papers. The PRD requires four locally reproduced baselines: plain decoding, two-model speculative decoding, plain cascading, and LayerSkip's published configuration.

Where used: docs/02_HNIA_PADS_PRD.md, src/eval/benchmark_harness.py, src/eval/run_baselines.py, docs/superpowers/plans/2026-09-23-pads-phase3-baselines.md; see /experiments.

Batch size

The number of training examples processed per optimizer step. The trainer's default is 4; the reported Phase 1 and held-out LoRA runs used 2 sequences of 512 tokens.

Where used: src/training/train_layerskip_lora.py (--batch), experiments/runs/2026-09-22T18-22-08Z-heldout-retrain/cmd.sh; see /technology.

Beam/greedy decoding

Greedy decoding takes the highest-probability token at each step; beam search keeps several candidate sequences alive and picks the best-scoring one. This project uses greedy decoding for every acceptance and policy measurement (--no_sample); beam search is not used.

Where used: src/training/eval_checkpoint_acceptance.sh, experiments/runs/2026-09-22T16-09-40Z-multiexit-eval/comparison.md; see /experiments.

BF16

bfloat16, a 16-bit floating-point format with 8 exponent bits and 7 mantissa bits: the same numeric range as fp32 but less precision. Training and evaluation load the LayerSkip checkpoint in torch.bfloat16.

Where used: src/training/train_layerskip_lora.py, src/training/merge_lora.py, src/eval/policy_eval.py; see /technology.

Bootstrap (cluster)

Resampling with replacement to estimate the uncertainty of a statistic. The Phase 2 policy comparison uses a prompt-level cluster bootstrap: 2000 resamples of the 40 prompts, never individual token positions, with a fixed seed.

Where used: experiments/runs/2026-09-22T19-18-00Z-phase2-policy-eval-heldout/make_comparison.py, experiments/runs/2026-09-22T19-18-00Z-phase2-policy-eval-heldout/comparison.md; see /experiments.

C

Caching (KV)

Storing the attention keys and values computed at earlier positions so a decode step does not recompute them. Speculative decoding depends on the draft and the verifier sharing the same cache, which is why depth extension must stay inside one model; see also KV cache.

Where used: docs/03_SKILL.md, src/pipeline/pads_pipeline.py; see /architecture.

Calibration

Choosing probability thresholds — and, ideally, making the probabilities themselves meaningful — so a decision rule has the intended error behaviour. Here the trigger thresholds are treated as parameters to be calibrated empirically rather than fixed a priori, and the dialogue-act classifier's probabilities are not calibrated to the deployment task.

Where used: src/trigger_policy/policy.py, paper/PADS_manuscript.tex, docs/02_HNIA_PADS_PRD.md; see /architecture.

Cascading

Running a cheap small model first and, when its confidence is low, discarding that output and rerunning the large model from scratch on the full prompt. It is a required baseline (no state is reused between stages); the Phase 3 plan implements it with Qwen2.5-0.5B as the small model.

Where used: docs/02_HNIA_PADS_PRD.md, src/eval/benchmark_harness.py (plain_cascading), docs/superpowers/plans/2026-09-23-pads-phase3-baselines.md; see /experiments.

Checkpoint

A saved set of model weights at a point in training. The project starts from the released LayerSkip 1B checkpoint (models/checkpoints/layerskip-1b-topv1-v5), saves LoRA checkpoints during training, and merges the final adapter before evaluation.

Where used: src/training/train_layerskip_lora.py (--save-every), experiments/runs/2026-09-22T18-22-08Z-heldout-retrain/checkpoint-500/, src/training/merge_lora.py; see /technology.

Confidence threshold

The probability cutoff a policy uses before escalating work. The token-confidence policy routes a position to full depth when the shallow exit's top-1 probability falls below its threshold, while the PADS trigger uses separate turn-ending (0.75) and deep-need (0.65) thresholds inside its AND gate.

Where used: src/eval/exit_policies.py, src/trigger_policy/policy.py; see /architecture.

CPU-only inference

Running the model on the CPU with no discrete GPU involved. The target is a Dell Latitude 5490 (8th-gen Intel CPU, 16 GB RAM); llama.cpp is built without CUDA/Metal flags, and only target-hardware CPU numbers are intended to be reported — those runs have not happened yet.

Where used: docs/03_SKILL.md, setup/setup_llama_cpp.sh, README.md; see /architecture.

Cross-entropy

The standard next-token training loss: the negative log of the probability assigned to the correct token. It is the per-exit term in this project's multi-exit loss.

Where used: src/training/early_exit_loss.py; see /technology.

CUDA

NVIDIA's GPU compute platform. It is used here only for training and host-side evaluation (PyTorch on an RTX 4070 laptop GPU); the inference build is deliberately CPU-only and the target laptop has no CUDA device.

Where used: experiments/runs/2026-09-22T18-22-08Z-heldout-retrain/cmd.sh, tools/guard.sh, setup/setup_llama_cpp.sh; see /technology.

D

DailyDialog

An openly licensed corpus of roughly 13k human-written dialogues with utterance-level dialogue-act tags, used as the source of proxy shallow/deep labels for the dialogue-act classifier because Switchboard-DAMSL is not openly downloadable.

Where used: src/dialogue_act/train_classifier_realdialog.py, experiments/results/dialogue_act_realdialog_metrics.json; see /technology.

Dialogue act

The function an utterance performs in a conversation — question, inform, directive, commissive, and so on — rather than its literal content. DailyDialog's four tags are mapped to proxy labels: question and directive to deep, inform and commissive to shallow.

Where used: src/dialogue_act/train_classifier_realdialog.py (LABEL_MAPPING), docs/02_HNIA_PADS_PRD.md; see /architecture.

Dialogue-act classifier

A TF-IDF + logistic-regression model that estimates p_deep, the probability that the eventual response needs full-depth reasoning, from a partial utterance. On the DailyDialog proxy test set it scores 0.8589 accuracy and 0.8559 macro-F1 against a 0.5494 majority-class baseline — measured on the proxy, not on the deployment task.

Where used: src/dialogue_act/train_classifier_realdialog.py, src/eval/exit_policies.py; see /architecture, /technology.

Depth extension

Continuing computation from the shallow exit through the remaining transformer layers to full depth; in PADS this is the speculative unit launched during a pause. The implementation resumes from the captured shallow hidden state rather than recomputing the early layers.

Where used: src/pipeline/pads_pipeline.py (continue_deep_logits), docs/01_HNIA_PADS_Detailed_Report.md; see /architecture.

Draft model

In standard speculative decoding, a smaller model that proposes tokens for a larger target model to verify; in self-speculative decoding the model's own shallow exit plays the draft role, so no second model is needed. The two-model variant is a required baseline, planned around a small Qwen2.5-0.5B draft GGUF.

Where used: docs/03_SKILL.md, docs/02_HNIA_PADS_PRD.md, docs/superpowers/plans/2026-09-23-pads-phase3-baselines.md; see /technology.

E

Early exit

Producing a usable prediction from an intermediate layer instead of the final one, so easy inputs can skip the remaining depth. LayerSkip trains the model so that any executed depth can predict through the shared LM head.

Where used: src/eval/exit_policies.py, src/training/early_exit_loss.py, paper/PADS_manuscript.tex; see /architecture.

Edge inference

Serving a model locally on resource-constrained hardware rather than in a data centre; here that means a 16 GB laptop with no discrete GPU, fully offline at inference time.

Where used: README.md, docs/02_HNIA_PADS_PRD.md, paper/PADS_manuscript.tex; see /architecture.

Energy measurement (RAPL, turbostat, powermeter)

Ways to measure power and energy: Intel RAPL counters under /sys/class/powercap/intel-rapl (read as microjoules), the turbostat and powertop command-line tools, or an in-line USB power meter as the pre-planned fallback. The harness records energy when RAPL is readable and stores None otherwise; Go/No-Go #6 checks which tool works on the target laptop.

Where used: src/eval/benchmark_harness.py, experiments/go_no_go/test6_energy_tooling.sh, src/eval/metrics.py (energy_joules); see /experiments.

EOS token

The special end-of-sequence token that terminates a generation. Training text appends EOS after every utterance, and a speculation that accepts EOS can end a generation immediately, which is how some empty generations arise.

Where used: src/training/train_layerskip_lora.py (build_blocks), experiments/runs/2026-09-22T16-09-40Z-multiexit-eval/comparison.md; see /technology.

Exit layer

The transformer layer whose hidden state feeds the shallow prediction. The project sweeps exits 4, 6, 8, 10, and 12, with layer 8 as the default in the pipeline and the policy probe.

Where used: src/eval/policy_eval.py, src/pipeline/pads_pipeline.py, src/training/eval_checkpoint_acceptance.sh; see /architecture, /experiments.

F

Falsification test (Go/No-Go)

A small, pre-registered experiment with an explicit kill signal, run before deeper implementation so a wrong premise is discovered cheaply. This project defines seven — bandwidth, pause duration, acceptance, thermal, RAM, energy tooling, and literature scoop — and gates pipeline work on all seven having logged results.

Where used: experiments/go_no_go/, experiments/go_no_go_results.md, docs/03_SKILL.md; see /experiments.

Fine-tuning

Continued training of released weights on a target data distribution. The project uses lightweight LoRA fine-tuning only and explicitly does not train a foundation model from scratch.

Where used: src/training/train_layerskip_lora.py, docs/03_SKILL.md; see /technology.

Float16/BFloat16

The two common 16-bit float formats: float16 spends 5 bits on the exponent (limited range, more mantissa precision) while bfloat16 spends 8 (fp32-like range, less precision). This project trains and evaluates in bfloat16, and uses IEEE F16 GGUF files only as the source for quantisation.

Where used: src/training/train_layerskip_lora.py, docs/03_SKILL.md; see /technology.

G

GGUF

llama.cpp's single-file model format, holding quantized weights plus metadata. The project converts HuggingFace weights to F16 GGUF and then quantizes to Q4_K_M for deployment; the downloaded LayerSkip GGUF lives at models/gguf/layerskip-1b-Q4_K_M.gguf, while several code paths still default to the placeholder name models/gguf/model-Q4_K_M.gguf.

Where used: setup/setup_llama_cpp.sh, docs/03_SKILL.md, models/gguf/layerskip-1b-Q4_K_M.gguf; see /technology.

Gradient checkpointing

Trading extra compute for memory by discarding intermediate activations and recomputing them during the backward pass. The reported LoRA runs enable it (--grad-checkpoint) so the manual layer loop fits in GPU memory.

Where used: src/training/train_layerskip_lora.py, experiments/runs/2026-09-22T18-22-08Z-heldout-retrain/cmd.sh; see /technology.

H

Held-out set

Data deliberately excluded from training so it can be used for honest measurement. Six AMI meetings containing evaluation items are excluded from the training corpus (leak check: 0/40 prompts and 0/40 responses remain), and 8 validation blocks are held out to track validation loss.

Where used: experiments/runs/2026-09-22T18-22-08Z-heldout-retrain/, experiments/results/heldout_leak_check.txt, src/training/train_layerskip_lora.py; see /experiments.

HuggingFace

The ecosystem of datasets, transformers, and peft libraries plus the model and dataset Hub, used here to load DailyDialog, the LayerSkip checkpoint, and the LoRA tooling.

Where used: src/dialogue_act/train_classifier_realdialog.py, src/training/train_layerskip_lora.py, setup/requirements.txt; see /technology.

I

Instruction tuning

Fine-tuning a pretrained language model on instruction/response pairs so it follows requests. This project does not perform instruction tuning; its literature review notes that post-training alignment can reduce a model's early-exit adaptability, which is why it starts from a LayerSkip checkpoint and fine-tunes with the LayerSkip recipe.

Where used: paper/PADS_manuscript.tex, docs/06_Literature_Survey.md; see /technology.

K

KV cache

The stored key/value tensors that let each new token attend to earlier ones without recomputing them. Caches are tied to a specific model's hidden dimension and layer count, so they cannot be handed between differently sized models — depth extension must stay within one model; and the Phase 2 routing probe has no KV-cache-aware depth switching, so it reports agreement, not latency.

Where used: docs/03_SKILL.md, src/eval/policy_eval.py, experiments/runs/2026-09-22T19-18-00Z-phase2-policy-eval-heldout/comparison.md; see /architecture.

L

Layer dropout

A LayerSkip training trick that randomly skips whole transformer layers during training, with rates that increase with depth, so the model learns to produce useful outputs at any executed depth. Here it is a per-batch keep mask with rates ramped from 0.0 to 0.5 — a documented simplification of the recipe, sampled per batch rather than per sample.

Where used: src/training/train_layerskip_lora.py (layer_dropout_rates); see /technology.

LayerSkip

Meta's ACL 2024 recipe (Elhoushi et al., arXiv:2404.16710) that trains one model with layer dropout and a shared early-exit loss, then uses its own shallow exit to draft tokens for full-depth verification. This project starts from the released layerskip-1b-topv1-v5 checkpoint and continues the recipe with LoRA.

Where used: src/training/train_layerskip_lora.py, models/checkpoints/layerskip-1b-topv1-v5, docs/01_HNIA_PADS_Detailed_Report.md; see /technology.

Learning rate

The step size the optimizer applies to weight updates. The training script defaults to 2e-4 and logs the value with every metrics record.

Where used: src/training/train_layerskip_lora.py (--lr), experiments/runs/2026-09-22T18-22-08Z-heldout-retrain/metrics.jsonl; see /technology.

Leakage (train/eval)

Training on data that later appears in evaluation, which inflates results. It was caught twice here: the original synthetic classifier demo scored a fake 1.000 because duplicated utterances appeared on both sides of the split, and the first multi-exit adapter's acceptance numbers were measured on an AMI meeting that was in its training corpus.

Where used: src/dialogue_act/train_classifier_realdialog.py, experiments/results/heldout_leak_check.txt, experiments/go_no_go_results.md; see /experiments.

llama.cpp

The open-source C/C++ inference engine used for CPU-only GGUF inference, driven here through its llama-cli binary and built with -DGGML_NATIVE=ON and the web UI target disabled.

Where used: setup/setup_llama_cpp.sh, src/eval/benchmark_harness.py (LLAMA_CLI); see /technology.

LLM

Large language model: a neural network, usually a transformer, trained to predict the next token over very large text corpora. PADS schedules how deep into one such model to compute, rather than choosing between two different models.

Where used: throughout the repository; see /architecture.

LoRA

Low-Rank Adaptation: keep the base weights frozen and train small low-rank matrices added to chosen projections. Here LoRA uses rank 16, alpha 32, dropout 0.05, and targets all attention and MLP projection matrices, so only a small fraction of parameters are trainable.

Where used: src/training/train_layerskip_lora.py (LoraConfig), src/training/merge_lora.py; see /technology.

Logistic regression

A linear classifier whose output is passed through a logistic function to give class probabilities; it is the classification head of the dialogue-act classifier (max_iter=1000, fixed seed).

Where used: src/dialogue_act/train_classifier_realdialog.py; see /technology.

Loss

The scalar objective training minimizes; here the next-token cross-entropy, summed over the primary exit and the auxiliary exits with weights. Training loss (measured with randomized layer dropout) and validation loss (full depth, no dropout) are deliberately not comparable.

Where used: src/training/early_exit_loss.py, src/training/train_layerskip_lora.py; see /technology.

M

Macro-F1

The unweighted mean of the per-class F1 scores, so each class counts equally even when the classes are imbalanced. The dialogue-act classifier scores 0.8559 macro-F1 on the DailyDialog proxy test set.

Where used: src/dialogue_act/train_classifier_realdialog.py, experiments/results/dialogue_act_realdialog_metrics.json; see /experiments.

Matched-compute comparison

Comparing two policies at the same compute budget rather than at the same threshold, because thresholds are not commensurate across policy families. Phase 2 interpolates agreement linearly in deep fraction to 25/50/75% budgets and never extrapolates beyond measured points; intervals come from the cluster bootstrap.

Where used: experiments/runs/2026-09-22T19-18-00Z-phase2-policy-eval-heldout/comparison.md, experiments/runs/2026-09-22T19-18-00Z-phase2-policy-eval-heldout/make_comparison.py; see /experiments.

Memory-bandwidth-bound

A regime where decode throughput is limited by how fast weights and caches can be read from memory rather than by arithmetic throughput. It is the central CPU risk to the PADS premise — idle compute during a pause helps little if memory is the bottleneck — and is what Go/No-Go #1's thread sweep probes; the host dry run showed the expected saturation (3B Q4_1 at roughly 14–15.6 tokens/s past 5–6 threads, noisy, one run per setting).

Where used: docs/01_HNIA_PADS_Detailed_Report.md, experiments/go_no_go/test1_bandwidth_vs_compute.sh, experiments/go_no_go_results.md; see /architecture.

Multi-exit loss

The training objective that adds one cross-entropy term per selected exit depth, all through the shared LM head; auxiliary exits use a token stride and a lower weight relative to the final exit. Here the auxiliary exits are layers 4/6/8/10/12 with weight 0.3 and stride 4, and logits are computed in chunks to bound memory.

Where used: src/training/early_exit_loss.py, src/training/train_layerskip_lora.py; see /technology.

N

N-gram

A contiguous sequence of n tokens. In this project n-grams are text features — the classifier's TF-IDF vectorizer uses unigrams and bigrams — not a decoding method.

Where used: src/dialogue_act/train_classifier_realdialog.py (ngram_range=(1, 2)); see /technology.

O

Oracle

The reference answer available only with hindsight. In the Phase 2 policy probe the oracle is the full-depth model's top-1 next token, and a policy's agreement is the fraction of positions whose chosen token matches it.

Where used: src/eval/policy_eval.py, experiments/runs/2026-09-22T19-18-00Z-phase2-policy-eval-heldout/comparison.md; see /experiments.

Overfitting

Fitting idiosyncrasies of the training data instead of generalizable patterns, so training performance overstates real performance. The synthetic classifier demo showed the extreme case (memorized duplicates and a fake 1.000 accuracy), and overfitting is one hypothesis offered for the weak 3.2-pass LoRA result.

Where used: experiments/go_no_go_results.md, src/dialogue_act/train_classifier.py; see /experiments.

P

Pause duration

The length of a silence gap between speech segments; PADS tries to hide deep computation inside it. The project's AMI-based proxy statistics cover 29,297 pauses across 171 meetings with a median of 1050 ms (gaps between 0.1 s and 5 s), with the explicit caveat that meeting speech is not telephone dialogue.

Where used: experiments/runs/2026-09-21T19-05Z-test2-pause-durations/ami_pause_stats.json, experiments/go_no_go/test2_pause_duration_check.py; see /architecture, /experiments.

PEFT

HuggingFace's Parameter-Efficient Fine-Tuning library, used to attach LoRA adapters to the base model, save them, and merge them back.

Where used: src/training/train_layerskip_lora.py, src/training/merge_lora.py; see /technology.

Perplexity

The exponential of the average negative log-likelihood per token, a standard language-modelling quality score. It is not computed anywhere in this project; the closest measured quantity is the held-out validation loss (4.8056 at step 10 to 3.3683 at step 1500 in the held-out run).

Where used: src/training/train_layerskip_lora.py (val_loss), experiments/runs/2026-09-22T18-22-08Z-heldout-retrain/metrics.jsonl; see /experiments.

Precision/Recall

Precision is the fraction of predicted positives that are correct; recall is the fraction of true positives the model finds. The dialogue-act classifier reports both per class, with F1 0.8767 for shallow and 0.8352 for deep on the proxy test set.

Where used: src/dialogue_act/train_classifier_realdialog.py, experiments/results/dialogue_act_realdialog_metrics.json; see /experiments.

Prompt

The input text a model conditions on when generating. All acceptance and policy phases use the same fixed 40-prompt AMI evaluation set so results stay comparable across phases.

Where used: experiments/runs/2026-09-21T19-10Z-test3-acceptance/conv_eval_ami.jsonl; see /experiments.

Q

Quantisation (Q4_K_M)

Reducing the numeric precision of model weights to cut memory use and memory bandwidth. Q4_K_M is a mixed 4-bit k-quant used as this project's default deployment format, produced with llama-quantize from an F16 GGUF — never from an already-quantized file — with Q5/Q6/Q8/F16 kept as calibration references.

Where used: setup/setup_llama_cpp.sh, docs/03_SKILL.md, models/gguf/layerskip-1b-Q4_K_M.gguf; see /technology.

R

Run manifest

A JSON file written at the start of every experiment that records the exact command, working directory, git revision (including whether the tree was dirty), hardware, model paths, configuration, and seed. Its purpose is reproducibility: any number can be traced back to the command that produced it, and a result from a dirty tree is flagged as suspect.

Where used: every directory under experiments/runs/; written by the training and evaluation drivers, described in /architecture.

ROUGE-L

A text-similarity score computed from the longest common subsequence between a generated text and a reference text, used here as a generation-quality proxy alongside acceptance. Values are near the floor on short AMI turns (off-the-shelf baseline 0.0368–0.0372); the held-out adapter measured 0.0429 on its non-empty denominator, with no confidence interval and with empty generations excluded.

Where used: experiments/runs/2026-09-22T16-09-40Z-multiexit-eval/comparison.md, experiments/runs/2026-09-22T18-22-08Z-heldout-retrain/acceptance_heldout.md; see /experiments.

S

Self-speculative decoding

Speculative decoding in which a single model drafts from its own shallow exit and verifies with its full depth, using the same KV cache for both. The LayerSkip benchmark invocation here uses --generation_strategy self_speculative with six speculations per step.

Where used: src/training/eval_checkpoint_acceptance.sh, docs/03_SKILL.md, paper/PADS_manuscript.tex; see /architecture, /technology.

Softmax

The function that turns a vector of logits into a probability distribution summing to one. It supplies the token-confidence signal (the top-1 softmax probability) and is applied inside the cross-entropy loss.

Where used: src/eval/exit_policies.py, src/training/early_exit_loss.py; see /technology.

Speculative decoding

Drafting several tokens cheaply, verifying them in one full model pass, and accepting only the prefix that matches the target model's output. Because verification preserves the target distribution, the final output is statistically unchanged; the project inherits this correctness guarantee and does not weaken it.

Where used: docs/03_SKILL.md, docs/02_HNIA_PADS_PRD.md, paper/PADS_manuscript.tex; see /architecture.

Stratified split

A train/test split that preserves class proportions in each part. The original synthetic classifier demo used a stratified 75/25 split with a fixed seed; the real-corpus classifier instead uses DailyDialog's official splits and removes train/test duplicates.

Where used: src/dialogue_act/train_classifier.py; see /technology.

Systemd scope (memory cap)

A transient systemd user scope that enforces MemoryMax and MemorySwapMax on a launched job, so a memory breach kills only that job (exit 137) instead of the desktop. Every heavy training or evaluation run here is launched through it.

Where used: tools/guard.sh; see /experiments.

T

TF-IDF

Term frequency–inverse document frequency: a weighting that values words frequent in a document but rare across the corpus. It is the feature representation for the dialogue-act classifier (unigrams and bigrams, min_df=1, a 215,529-term vocabulary on the DailyDialog corpus).

Where used: src/dialogue_act/train_classifier_realdialog.py, experiments/results/dialogue_act_realdialog_metrics.json; see /technology.

Thermal throttling

The frequency and voltage reduction a chip applies when it gets too hot, which makes repeated benchmark runs non-reproducible. The project's 30-minute sustained-load check observed up to 103 °C on a host 3B substitute, so warm-up-and-discard remains a permanent part of the benchmark protocol; the target-hardware result is still pending.

Where used: experiments/go_no_go/test4_thermal_stability.sh, experiments/go_no_go_results.md, src/eval/benchmark_harness.py; see /experiments.

Token

The atomic unit of text an LLM reads and writes, usually a subword fragment. Generation is capped at 128 tokens per prompt in the harnesses, and individual token positions are what the token-confidence policy routes.

Where used: src/eval/benchmark_harness.py, src/eval/policy_eval.py; see /technology.

Token confidence

The shallow exit's top-1 softmax probability for the next token, used as an early-exit criterion: positions whose confidence is below a threshold are recomputed at full depth. At matched compute in Phase 2, token confidence agreed with the full-depth oracle more often than the dialogue-act policy at every budget.

Where used: src/eval/exit_policies.py, experiments/runs/2026-09-22T19-18-00Z-phase2-policy-eval-heldout/comparison.md; see /architecture, /experiments.

Tokenizer

The component that maps text to token IDs and back, including the model's EOS token. An independent tokenizer cross-check reproduced the per-prompt next-token counts of the Phase 2 probe exactly in 40/40 prompts (953 positions total).

Where used: experiments/runs/2026-09-22T19-18-00Z-phase2-policy-eval-heldout/tokenizer_check.json, src/training/train_layerskip_lora.py; see /technology.

Transformer

The attention-based neural architecture behind modern LLMs, made of stacked decoder layers. Its depth — the number of layers — is the axis PADS schedules: a shallow exit versus full depth of the same network.

Where used: src/pipeline/pads_pipeline.py, paper/PADS_manuscript.tex; see /architecture.

TTFT

Time to first token: the wall-clock delay from request to the first generated token, the metric PADS claims to reduce. The harness takes it from llama-cli's prompt timing (or derives it as 1/prompt tokens-per-second from the modern summary line), and the pipeline composes a perceived TTFT for each trigger outcome.

Where used: src/eval/metrics.py (ttft_ms), src/eval/benchmark_harness.py (parse_timings), src/pipeline/pads_pipeline.py (compose_ttft_ms); see /architecture, /experiments.

Turn-taking prediction

Estimating from streaming audio whether the current speaker is about to finish, producing the p_end signal. The project defines the interface — update(audio_chunk) -> P(turn ending within ~300 ms) — but has not implemented it; the pipeline uses a scripted or injected probability in the meantime.

Where used: src/turn_taking/README.md, src/trigger_policy/policy.py, src/pipeline/pads_pipeline.py; see /architecture.

V

VAP (voice activity projection)

Voice Activity Projection: a self-supervised approach that predicts future voice activity and turn-taking events from audio, with real-time CPU-capable implementations. It is the recommended basis for this project's turn-taking predictor.

Where used: src/turn_taking/README.md, docs/01_HNIA_PADS_Detailed_Report.md, paper/PADS_manuscript.tex; see /architecture.

Validation split

Data held out from training for monitoring and model selection but not used as the final test. DailyDialog's official validation split (1,000 dialogues / 8,069 utterances) is loaded, and the trainer holds out 8 validation blocks to compute val_loss — which is not used for early stopping.

Where used: src/dialogue_act/train_classifier_realdialog.py, src/training/train_layerskip_lora.py (--val-blocks); see /technology.

VRAM

Video RAM: GPU memory. Phase 1 LoRA training peaked at about 5.1 GB on the RTX 4070, and the guard refuses GPU jobs when free memory is below the requested threshold.

Where used: experiments/go_no_go_results.md, tools/guard.sh (GUARD_MIN_GPU_MB); see /technology.

W

Warm-up runs

Untimed runs executed before measurement and discarded, so clock ramping and thermal state do not contaminate the first measured run. The benchmark harness discards 2 warm-up runs per configuration before its 8 measured runs, and the pipeline's timing helper does 1.

Where used: src/eval/benchmark_harness.py (WARMUP_RUNS), src/pipeline/pads_pipeline.py; see /experiments.

Z

Zero-shot

Evaluating a model on a task it was not specifically trained for. The off-the-shelf LayerSkip checkpoint evaluated on the AMI set — the baseline arm in the acceptance and policy comparisons, which saw none of the project's training data — is this project's zero-shot baseline.

Where used: experiments/runs/2026-09-22T18-22-08Z-heldout-retrain/acceptance_heldout.md, docs/03_SKILL.md (Go/No-Go #3); see /experiments.