Feature-Specific Error Correction

• Feature-specific error correction is a targeted approach that localizes modifications to the most error-prone features while preserving correct system behavior.
• In on-device vision systems, prototype adaptation shifts class prototypes near corrected exemplars, improving one-shot correction rates with minimal forgetting.
• Selective correction in ASR and text leverages confidence scores, token masking, and span-based edits to reduce errors effectively without affecting already correct outputs.

Feature-specific error correction denotes a family of methods that localize corrective action to the particular features, positions, modes, or residual error patterns associated with failure, rather than applying uniform global retraining or unrestricted rewriting. In compact on-device vision systems, this is realized by moving class prototypes in feature space near corrected exemplars while freezing the backbone (Paramonov et al., 26 Nov 2025). In ASR, it appears as per-token selective correction driven by soft error detection, confidence references, acoustic references, or phoneme-aware multimodal fusion (Leng et al., 2022, Shu et al., 2024, He et al., 31 May 2025). In coding and decoding, it targets dominant residual patterns that determine the error floor or the decoder’s failure basin (Park et al., 13 Feb 2025). In paragraph-level proofreading, it jointly repairs co-occurring linguistic and factual error features within a shared context (Kai et al., 27 Feb 2026). Across these formulations, the central objective is to improve performance on the erroneous subset while preserving already correct behavior under constraints such as latency, memory, privacy, or over-correction.

1. Conceptual foundations

Across the cited literature, “feature-specific” does not refer to a single algorithmic primitive. Instead, it denotes selective correction at the granularity most relevant to the task. In low-resource visual recognition, the unit is a class prototype or a particular intra-class mode in embedding space; in ASR it is often a token position or a detected change site; in real-word spelling correction it can be a token ranked against semantically constrained alternatives; in coding it is a structured residual pattern that survives a first decoder pass; and in paragraph-level proofreading it is a mixed set of word, grammar, punctuation, and factual edits within one paragraph (Paramonov et al., 26 Nov 2025, Leng et al., 2022, Park et al., 13 Feb 2025, Kai et al., 27 Feb 2026).

A compact formalization is given for on-device visual correction. A device-side feature extractor $f(x) \in \mathbb{R}^d$ processes a stream of inputs, the test stream is partitioned into correctly classified $D_C$ and misclassified $D_E$, and the adapted system $M_A$ should increase accuracy on $D_E$ while preserving performance on $D_C$ under strict memory and latency budgets (Paramonov et al., 26 Nov 2025). In SoftCorrect, the corresponding formal idea is per-token selective correction: detect which tokens are likely incorrect, duplicate only those tokens for constrained CTC alignment, and preserve the remaining positions as anchors (Leng et al., 2022). In CLFEC, the formal object is a paragraph-level edit set $\mathcal{E} = \{(s_k,e_k,u_k,v_k)\}_{k=1}^K$ whose strict span matching is evaluated jointly over linguistic and factual corrections (Kai et al., 27 Feb 2026).

Setting	Error-specific unit	Correction mechanism
Low-resource vision	Class/mode prototype	Prototype adaptation in feature space
ASR	Token or change site	Soft detection, constrained decoding, or multimodal references
Text correction	Token or span	Semantic ranking, confusion-set classification, or span replacement
Coding and QEC	Residual error pattern	Hybrid decoding or recovery optimization

This diversity of formulations implies that feature-specificity is primarily a design principle. The common pattern is targeted modification of the part of the representation or hypothesis space that is implicated in the observed error, while other parts are explicitly frozen, anchored, or regularized.

2. Prototype adaptation in feature space on low-resource devices

The most explicit systems-level formulation appears in "Continual Error Correction on Low-Resource Devices" (Paramonov et al., 26 Nov 2025). The server side domain-finetunes a DINO-v2-small teacher with a prototypical objective, distills its representation geometry into a MobileNet-V2 student, and then clusters student features per class to produce $K$ prototypes per class. The representation-level distillation used in the system is

$$L_{KD} = \frac{1}{n} \sum_{i=1}^n \left|F_T(X_i) - M(X_i)\right|.$$

After distillation, features are clustered per class by K-means, producing a global prototype set shipped with the student backbone to the device. The device computes $f(x)=M_T(x)\in\mathbb{R}^d$ and predicts by prototype similarity, using cosine similarity in practice because of robustness under scale variations in $D_C$0:

$D_C$1

The correction mechanism is strictly localized. When a user flags a mistake and provides the true label, only the prototypes of the true class are updated; prototypes of other classes remain unchanged. The simplest one-shot update appends $D_C$2 to the prototype set of the corrected class, subject to memory constraints. For a single dominant prototype, the paper uses an EMA update

$D_C$3

and for few-shot correction it maintains a centroid over buffered exemplars assigned to the nearest prototype. With multiple prototypes per class, only the nearest mode is updated, which makes the correction feature-specific at the sub-class or attribute level rather than diluting all modes.

The paper treats this locality as the reason prototype correction is compatible with device constraints. Update complexity is $D_C$4 per correction and inference complexity is $D_C$5 for cosine scoring. Prototype storage is approximately $D_C$6 bytes. For $D_C$7 and Food-101, this yields about $D_C$8; with $D_C$9 and float32, the reported example is approximately $D_E$0 MB, and with $D_E$1-bit quantized prototypes it is approximately $D_E$2 MB. Models are quantized to $D_E$3-bit TFLite, yielding approximately $D_E$4 speedups with less than $D_E$5 accuracy loss. On a Samsung Galaxy S24 Ultra with the TFLite C++ interpreter, the YOLOv8-nano $D_E$6-bit detector is approximately $D_E$7 MB and runs in approximately $D_E$8 ms, versus $D_E$9 ms for the $M_A$0-bit version.

Empirically, the base recognition accuracy of the distilled backbone with initial prototypes is $M_A$1 on Food-101 and $M_A$2 on Flowers-102. One-shot correction accuracy on the misclassified subset reaches $M_A$3 on Food-101 and $M_A$4 on Flowers-102, with forgetting rates of $M_A$5 and $M_A$6, respectively. At ten-shot, error correction accuracy reaches $M_A$7 and $M_A$8, with forgetting $M_A$9 and $D_E$0; at fifty-shot it reaches $D_E$1 and $D_E$2, with forgetting $D_E$3 and $D_E$4. The forgetting metric is defined by $D_E$5, where $D_E$6 is accuracy on the previously correct subset after adaptation. The reported interpretation is direct: freezing $D_E$7 and updating only prototypes is the key to minimal forgetting.

The same prototype machinery is extended to object detection. A quantized YOLOv8-nano detector proposes boxes, crops are passed through the distilled backbone, and detections are scored by prototype similarity:

$D_E$8

The detector reports $D_E$9 on OpenImages-V7 after $D_C$0-bit quantization. The paper also reports that a single-backbone variant can reuse detection-head features with a small relative accuracy trade-off of less than $D_C$1 in prior art. The broader implication is that feature-specific correction can be implemented as a post-training representational layer over a frozen backbone, rather than as repeated backpropagation on the device.

3. Selective correction in automatic speech recognition

ASR provides several distinct realizations of feature-specific correction. In "SoftCorrect" (Leng et al., 2022), the central idea is to detect likely incorrect tokens and restrict dynamic alignment to those positions. A Transformer encoder produces per-position probabilities over the vocabulary augmented with a special GT token, trained with an anti-copy language modeling loss. The detector score is a weighted linear combination of encoder probability and ASR output probability, thresholded to produce an error mask. Only masked tokens are duplicated for constrained CTC, while unmasked tokens are copied as anchors. Standard CTC allows all positions to be dynamically editable; SoftCorrect’s constrained CTC permits dynamic alignment only at the detected error positions. On AISHELL-1, test CER falls from $D_C$2 to $D_C$3, a $D_C$4 reduction; on Aidatatang, test CER falls from $D_C$5 to $D_C$6, a $D_C$7 reduction. On a V100 GPU, inference latency is $D_C$8 ms per sentence versus $D_C$9 ms for AR N-Best; on CPU, it is $\mathcal{E} = \{(s_k,e_k,u_k,v_k)\}_{k=1}^K$0 ms versus $\mathcal{E} = \{(s_k,e_k,u_k,v_k)\}_{k=1}^K$1 ms. The detector itself achieves, on AISHELL-1, $\mathcal{E} = \{(s_k,e_k,u_k,v_k)\}_{k=1}^K$2, $\mathcal{E} = \{(s_k,e_k,u_k,v_k)\}_{k=1}^K$3, $\mathcal{E} = \{(s_k,e_k,u_k,v_k)\}_{k=1}^K$4, with correction precision $\mathcal{E} = \{(s_k,e_k,u_k,v_k)\}_{k=1}^K$5.

A different non-autoregressive formulation appears in "Error Correction by Paying Attention to Both Acoustic and Confidence References for Automatic Speech Recognition" (Shu et al., 2024). Here the corrector receives two feature-specific reference streams per token position: an acoustic reference from the $\mathcal{E} = \{(s_k,e_k,u_k,v_k)\}_{k=1}^K$6th layer of a $\mathcal{E} = \{(s_k,e_k,u_k,v_k)\}_{k=1}^K$7-layer Conformer encoder and a confidence reference from a dedicated confidence estimation module. N-best hypotheses are aligned by edit path, confidence embeddings are fused by a learnable interpolation layer, and a $\mathcal{E} = \{(s_k,e_k,u_k,v_k)\}_{k=1}^K$8-layer decoder performs self-attention plus two cross-attentions, one to acoustics and one to confidence features. The confidence module achieves test/dev accuracy $\mathcal{E} = \{(s_k,e_k,u_k,v_k)\}_{k=1}^K$9, precision $K$0, recall $K$1, F1 $K$2, specificity approximately $K$3–$K$4, and NCE approximately $K$5. The full system with $K$6-best fusion, confidence, and acoustics reduces test CER to $K$7 and dev CER to $K$8, corresponding to $K$9 and $$L_{KD} = \frac{1}{n} \sum_{i=1}^n \left|F_T(X_i) - M(X_i)\right|.$$0 CER reduction relative to the ASR baseline, while maintaining approximately $$L_{KD} = \frac{1}{n} \sum_{i=1}^n \left|F_T(X_i) - M(X_i)\right|.$$1 ms per sentence on an NVIDIA V100.

"PMF-CEC: Phoneme-augmented Multimodal Fusion for Context-aware ASR Error Correction with Error-specific Selective Decoding" adds yet another selective mechanism (He et al., 31 May 2025). It inserts dummy tokens between ASR words, predicts per-position KEEP/DELETE/CHANGE labels, and decodes only change sites. The distinctive feature-specific input is phoneme information: phoneme sequences for the ASR source and each contextual rare-word item are encoded by XPhoneBERT and fused with text representations by cross-attention. To reduce overdetection, the paper introduces a retention probability mechanism that accepts the AED-predicted label only if confidence exceeds a threshold, reported as $$L_{KD} = \frac{1}{n} \sum_{i=1}^n \left|F_T(X_i) - M(X_i)\right|.$$2 in experiments. The full model improves over ED-CEC across five datasets; on LibriSpeech test-clean, WER falls from $$L_{KD} = \frac{1}{n} \sum_{i=1}^n \left|F_T(X_i) - M(X_i)\right|.$$3 to $$L_{KD} = \frac{1}{n} \sum_{i=1}^n \left|F_T(X_i) - M(X_i)\right|.$$4 and B-WER from $$L_{KD} = \frac{1}{n} \sum_{i=1}^n \left|F_T(X_i) - M(X_i)\right|.$$5 to $$L_{KD} = \frac{1}{n} \sum_{i=1}^n \left|F_T(X_i) - M(X_i)\right|.$$6; on test-other, WER falls from $$L_{KD} = \frac{1}{n} \sum_{i=1}^n \left|F_T(X_i) - M(X_i)\right|.$$7 to $$L_{KD} = \frac{1}{n} \sum_{i=1}^n \left|F_T(X_i) - M(X_i)\right|.$$8 and B-WER from $$L_{KD} = \frac{1}{n} \sum_{i=1}^n \left|F_T(X_i) - M(X_i)\right|.$$9 to $f(x)=M_T(x)\in\mathbb{R}^d$0. The reported latency is $f(x)=M_T(x)\in\mathbb{R}^d$1–$f(x)=M_T(x)\in\mathbb{R}^d$2 ms per utterance, approximately $f(x)=M_T(x)\in\mathbb{R}^d$3–$f(x)=M_T(x)\in\mathbb{R}^d$4 faster than autoregressive BART correction.

Taken together, these systems show three complementary ways of being feature-specific in ASR: masking only detected tokens, conditioning on token-level uncertainty and acoustics, or decoding only predicted change sites with phoneme-aware context fusion. In each case, already correct tokens are explicitly protected by anchors, pass-through behavior, or confidence-based retention.

4. Symbol-space, lexical, and span-level correction

Feature-specific correction is also prominent in text correction systems that operate in discrete candidate spaces. "Automatic Real-word Error Correction in Persian Text" constructs a multi-tier pipeline with FarsNet-backed semantic relations, N-gram probabilities, semantic-set aggregation, and SVM-based detection (Dashti et al., 2024). Features include word N-gram probabilities, stemmed N-gram probabilities, semantic N-gram probabilities derived from semantic alternatives within a fixed window of $f(x)=M_T(x)\in\mathbb{R}^d$5, and $f(x)=M_T(x)\in\mathbb{R}^d$6 character-frequency features. The semantic probability for a search space is the average probability of all semantic combinations in the space. Detection uses an SVM with 10-fold cross-validation; kernels tested are linear, RBF, and sigmoid, with $f(x)=M_T(x)\in\mathbb{R}^d$7 for non-linear kernels, and the strongest reported configuration is a sigmoid kernel with $f(x)=M_T(x)\in\mathbb{R}^d$8. Best overall detection reaches $f(x)=M_T(x)\in\mathbb{R}^d$9 on Set3 for mixed-distance errors at $D_C$00, and best-case correction reaches $D_C$01 for distance-1 errors at $D_C$02. The broader mixed-distance correction score is approximately $D_C$03 at $D_C$04. The paper identifies word N-grams and stem-based semantic sets as the most prominent features, which makes the approach feature-specific in the sense of ranking corrections by contextual and semantic fit rather than by surface similarity alone.

"OCR Error Correction Using Character Correction and Feature-Based Word Classification" exemplifies a similar principle in post-OCR processing (Kissos et al., 2016). Candidate generation targets the dominant OCR error classes in the dataset: primitive $D_C$05-Levenshtein edits, $D_C$06 merges, $D_C$07 splits, and spacing errors. These classes cover $D_C$08 of erroneous words in the test set, split roughly into half substitutions, $D_C$09 deletions/insertions, $D_C$10 merges/splits, and $D_C$11 spacing errors. A weighted confusion matrix generates candidates, a logistic-regression ranker scores them using confusion weight, unigram frequency, and forward/backward bigram frequencies, and a second classifier decides whether to replace the OCR token with the top-ranked candidate using OCR confidence and proportional dictionary features. The correct spelling is retrieved among the generated candidates for $D_C$12 of misspelled words; when the correct candidate is present, the logistic-regression ranker places it in the top-$D_C$13 in $D_C$14 of cases, with top-$D_C$15 accuracy $D_C$16. The decision classifier rejects a correct OCR word only $D_C$17 of the time and replaces an incorrect OCR word $D_C$18 of the time. End-to-end WER falls from $D_C$19 to $D_C$20.

"A Simple but Effective Classification Model for Grammatical Error Correction" constrains correction by error type and confusion set (Kaili et al., 2018). Articles are predicted from $D_C$21, prepositions from $D_C$22, verb form from $D_C$23, noun number from $D_C$24, and subject–verb agreement from $D_C$25. Detection is rule-based, target positions are POS-triggered, and left and right contexts are encoded by GRUs with either context-only or target-aware attention. Trained on pseudo-labels mined from Wikipedia and COCA rather than human correction annotations, the neural classifier reaches CoNLL-2014 precision $D_C$26, recall $D_C$27, and $D_C$28; the hybrid system with an SMT component reaches precision $D_C$29, recall $D_C$30, and $D_C$31. This is feature-specific correction in a strict classification sense: each target is corrected only within a small, type-specific set of alternatives.

Request-dialog repair applies the same idea at the span level. "Error correction and extraction in request dialogs" takes the last two utterances, detects whether the latter corrects the former, and if so outputs both a corrected request and reparandum–repair pairs (Constantin et al., 2020). The sequence-labeling formulation uses labels $D_C$32 over the concatenation of the two utterances, where $D_C$33 and $D_C$34 mark reparandum and repair spans. A pipeline with a BERT-large sequence labeler as detector and a T5-generate corrector trained on correction-only data reaches $D_C$35 accuracy on synthetic validation data and $D_C$36 on human-created real-world test data. Because only entity spans are replaced, the method localizes correction while preserving the rest of the request.

5. Coding-theoretic, quantum, and mechanistic variants

In coding theory, feature-specific error correction often means targeting the structured residual patterns that dominate failure. "Lowering the Error Floor of Error Correction Code Transformer" studies the error floor of ECCT and introduces a hybrid decoder that wraps ECCT with hard-decision pre- and post-decoders (Park et al., 13 Feb 2025). The pre-decoder prevents ECCT from degrading inputs already within the hard-decision correction radius $D_C$37, while the post-decoder finishes correction when ECCT reduces residual errors below $D_C$38. The proposed loss gates learning on precisely those cases that the pre-decoder cannot fix and the post-decoder still cannot finish, which makes the objective explicitly dependent on hybrid decoding dynamics. For BCH $D_C$39, FER at $D_C$40 dB improves from $D_C$41 for ECCT to $D_C$42 for Pre+ECCT+Post+loss; for BCH $D_C$43, it improves at $D_C$44 dB from $D_C$45 to $D_C$46. The paper’s interpretation is that ECCT acts as a “feature-specific reducer” of hard residual patterns, while the post-decoder completes correction inside its bounded-distance radius.

"Error Correction for Partially Stuck Memory Cells" uses “feature-specific” in a different, code-construction sense (Kim et al., 2019). The relevant feature is the defect model: a partially stuck cell at level $D_C$47 can store only values at least $D_C$48, rather than being fixed to a single value. For the detailed case $D_C$49 and $D_C$50, the construction exploits this asymmetry by choosing a single offset $D_C$51 so that every defective coordinate becomes nonzero. Combined with an error-correcting code, this yields $D_C$52-partially-stuck-at-masking codes with total redundancy $D_C$53 rather than the higher masking redundancy associated with fully stuck cells. The cyclic-code construction permits efficient bounding of error-correction capability through the BCH bound, and the paper states that for $D_C$54 and $D_C$55, all new constructions require less redundancy for masking partially stuck cells than previous work on stuck cells.

In near-term quantum devices, "Robustness-optimized quantum error correction" targets recovery faults rather than only physical decoherence (Layden et al., 2019). For a three-qubit phase-flip repetition code under quasi-static dephasing, the recovery channel is optimized by mixing faulty measurement-and-feedback recovery with measurement-only Zeno stabilization. The mixture parameter is $D_C$56, the probability of applying feedback after syndrome extraction. For $D_C$57 and $D_C$58, the optimal strategy among those studied uses $D_C$59 recoveries and $D_C$60, achieving average fidelity $D_C$61. The paper shows three regimes across $D_C$62: conventional QEC with $D_C$63, Zeno-only with $D_C$64, and an intermediate hybrid regime with $D_C$65 near $D_C$66. Here feature-specificity means tailoring recovery to the experimentally dominant fault mode, namely syndrome misclassification.

At a mechanistic level, "Evidence for feature-specific error correction in LLMs" argues that if computation in superposition is real, internal error suppression must privilege feature directions over generic mixtures (Silva et al., 23 Jun 2026). The empirical test perturbs residual-stream activations and fits the plateau-breaking boundary by an $D_C$67 geometry. For contrastive directions, the mean fitted exponent is $D_C$68 with $D_C$69 CI $D_C$70; for MELBO directions it is $D_C$71; for SAE-decoder directions it is $D_C$72; for PCA, random-difference, and random directions it is approximately $D_C$73, $D_C$74, and $D_C$75. The paper argues that $D_C$76 corresponds to a quadratic form with rank at most the residual-stream dimension and therefore cannot privilege the many feature directions superposition requires, whereas $D_C$77 is consistent with feature-specific error correction. This is not an application-level correction system, but it provides a mechanistic claim that feature-aligned robustness may be a real property of contemporary LLMs.

6. Evaluation criteria, failure modes, and design implications

A recurring concern across the literature is not merely whether errors are corrected, but whether already correct content is preserved. In the on-device vision setting, this is formalized by the forgetting rate $D_C$78, with one-shot forgetting remaining at $D_C$79 on Food-101 and $D_C$80 on Flowers-102 (Paramonov et al., 26 Nov 2025). In SoftCorrect, the same concern motivates soft detection and constrained CTC, because recent ASR systems already have low word error rate and therefore over-correction of correct tokens is costly (Leng et al., 2022). In CLFEC, over-correction on clean inputs is tracked by Edit Rate per $D_C$81 characters, and sequential RAG is reported to inflate edits even on the Error-free split, whereas agentic verification suppresses this effect (Kai et al., 27 Feb 2026). In PMF-CEC, the retention probability mechanism is introduced specifically to filter low-confidence edit operations and reduce overdetection (He et al., 31 May 2025).

Failure modes are correspondingly localized. The low-resource vision system reports degradation under distribution shift beyond learned modes, misaligned teacher–student features, highly confusable classes, and tight memory budgets that force prototype eviction (Paramonov et al., 26 Nov 2025). SoftCorrect notes miscalibration of detector probabilities, hard deletions that never appear in the N-best list, and domain robustness issues when errors are difficult to detect (Leng et al., 2022). CLFEC identifies a masking effect in mixed-error paragraphs, where surface linguistic fixes can obscure deeper factual inconsistencies; grammar and punctuation also remain recall bottlenecks relative to word and factual errors (Kai et al., 27 Feb 2026). Persian real-word correction observes false negatives when synthetic errors happen to be semantically plausible in context, and the OCR pipeline remains limited by out-of-domain language-model sparsity and multi-error misspellings (Dashti et al., 2024, Kissos et al., 2016).

These results suggest a common design pattern, although the individual systems differ sharply in architecture. A plausible implication is that effective feature-specific correction typically combines three ingredients: a representation or detector that localizes likely error-bearing features, a restricted correction mechanism that edits only those features, and a safeguard against collateral change. In different domains, the safeguard may be prototype freezing, anchor tokens, hard-decision pre/post decoders, confidence thresholds, verification tools, or strict span matching. The literature does not imply that one mechanism is universally preferable. Rather, it indicates that feature-specific correction is most useful when errors are sparse, structured, and costly to fix globally, and when preserving correct behavior is itself a first-class objective.