DQInit: Initialization in ML & Optimization

• DQInit is a set of initialization strategies that inject structured prior information early in machine learning workflows for enhanced inference and optimization.
• In facial landmark detection, dynamic query initialization replaces static decoder queries, reducing layers while achieving competitive accuracy.
• DQInit also covers value initialization in deep reinforcement learning and structured setups in decentralized optimization to improve performance and stability.

DQInit is a term used for several initialization mechanisms across contemporary machine learning and optimization. Its most specific and technically developed meaning is dynamic query initialization in a DETR-style transformer for facial landmark detection, where decoder queries are generated from the current input feature map rather than treated as static learned embeddings (Jin et al., 2021). In later literature, the same label also denotes value function initialization for deep reinforcement learning, and it appears more loosely as a shorthand for admissible initialization procedures in decentralized second-order optimization (Mehimeh, 12 Aug 2025, Mokhtari et al., 2015, Shorinwa et al., 2024). The literature represented here therefore does not use DQInit for a single standardized algorithm; instead, it uses the term for initialization strategies that inject structured prior information into early stages of inference, optimization, or transfer learning.

1. Terminological scope and neighboring usages

Within the cited literature, DQInit has at least three distinct meanings. In facial landmark detection, it denotes a lightweight module that computes image-conditioned transformer queries from backbone memory (Jin et al., 2021). In deep reinforcement learning, it denotes “Deep Q-values Initialization,” a method that reuses compact tabular Q-values from previously solved tasks as a transferable knowledge base (Mehimeh, 12 Aug 2025). In decentralized optimization, the term is used descriptively for initialization of DQM and DQN-type methods, especially for choosing admissible primal, dual, and curvature states before iterative updates begin (Mokhtari et al., 2015, Bajovic et al., 2015, Shorinwa et al., 2024).

Several adjacent abbreviations can be confused with DQInit but refer to different constructs. “DQ-Whisper” is a joint distillation and quantization framework for compressing Whisper models (Shao et al., 2023). “Decoded Quantum Interferometry” is abbreviated DQI and concerns a non-variational quantum optimization algorithm under local depolarizing noise (Bu et al., 14 Aug 2025). “Adaptive Dataset Quantization” is abbreviated ADQ and redesigns dataset-compression sampling over quantized bins (Li et al., 2024). This suggests that DQInit is best treated as a context-dependent term whose meaning is fixed by the surrounding method family rather than by the acronym alone.

2. Dynamic query initialization in facial landmark detection

The canonical use of DQInit appears in “When Liebig’s Barrel Meets Facial Landmark Detection: A Practical Model” (Jin et al., 2021). The model uses an ImageNet-pretrained CNN backbone, removes the DETR encoder, and treats the final backbone feature map as transformer memory

$M \in \mathbb{R}^{d \times h \times w}.$

A single transformer decoder layer serves as the detection head, the number of queries $N$ is set equal to the number of landmarks, and the decoder output is regressed directly to $N$ landmark coordinates with an L1 loss on coordinates.

The motivation is empirical and architectural. With zero or static DETR-style queries, stacking more decoder layers improves WFLW NME from $4.31$ with one decoder to $4.24$ with five to seven decoders, but each decoder layer adds about $1.6$M parameters together with latency, FLOPs, memory use, and an extra hyperparameter (Jin et al., 2021). DQInit is introduced to recover the refinement effect of deeper decoders while retaining a one-layer practical configuration.

Formally, DQInit computes the initial query matrix by global pooling followed by a fully connected projection:

$$Q_{\text{init}} = \text{FC}(\text{GlobalAvgPool}(M)).$$

If

$g = \text{GlobalAvgPool}(M) \in \mathbb{R}^{d},$

then the fully connected layer maps $g$ to $Q_{\text{init}} \in \mathbb{R}^{N \times d}$. In the reported implementation, $N$0. The module contains no attention; it is only a global average pooling layer and a fully connected layer. Its parameter cost is about $N$1M, which is larger than a single decoder layer in parameter count, but the paper characterizes it as computationally lightweight relative to the backbone and transformer (Jin et al., 2021).

Its effect is measured mainly on WFLW with ResNet-50, stride 32, and one decoder layer. The baseline without DQInit or QAMem obtains $N$2 NME. Adding DQInit alone reduces this to $N$3; adding QAMem alone yields $N$4; combining DQInit and QAMem reaches $N$5, matching the five- to seven-decoder baseline while preserving a single-decoder architecture (Jin et al., 2021). On the full benchmark, the ResNet-50 BarrelNet variant improves from $N$6 to $N$7 NME, and the ResNet-101 variant reaches $N$8 NME, reported as state of the art on WFLW. The broader practical claim is that DQInit replaces fixed queries with image-dependent queries so that one decoder layer can behave competitively with a deeper stack while the full model still runs at $N$9 FPS.

3. DQInit as value function initialization in deep reinforcement learning

A second, independent meaning is introduced in “Value Function Initialization for Knowledge Transfer and Jump-start in Deep Reinforcement Learning” (Mehimeh, 12 Aug 2025). Here DQInit denotes a method that adapts tabular value function initialization to deep RL by transferring compact Q-tables extracted from previously solved tasks into a deep Q-learning pipeline. The target setting is continuous-state DRL with function approximation, where direct reuse of prior neural policies or prior Q-networks is considered unstable or storage-intensive.

The central object is an adaptive mixture between transferred and learned values:

$N$0

Here $N$1 is the transferred initialization derived from a discretized tabular knowledge base, and $N$2 is the current deep Q-network. The interpolation weight is a knownness measure defined on a discretized abstraction $N$3:

$N$4

where $N$5 is the visit count of the corresponding discretized bin, $N$6 is a visitation threshold, and $N$7 controls transition sharpness. Unknown regions therefore defer to transferred values, while frequently visited regions defer to the learned network. The paper explicitly frames this as avoiding the limitations of fixed time decay.

The transferred initializer $N$8 is built from tabular Q-values aggregated across prior tasks, using value-function initialization rules such as MaxQInit, UCOI, and LOGQInit. DQInit can then be integrated into DQN in three ways: soft policy guidance through greedy action selection with $N$9, an auxiliary value-alignment loss toward $4.31$0, and a KL-based policy distillation loss toward the policy induced by $4.31$1 (Mehimeh, 12 Aug 2025). This makes DQInit neither a one-shot parameter initialization nor a pure imitation method; it is an adaptive transfer mechanism whose influence is state-action dependent.

The experiments use task distributions derived from MountainCar, Acrobot, and CartPole. For each environment, $4.31$2 source tasks are used to build the tabular knowledge base and $4.31$3 new tasks are used for transfer evaluation. The paper reports that DQInit consistently improves early learning efficiency, stability, and overall performance compared to standard initialization and existing transfer techniques (Mehimeh, 12 Aug 2025). It also reports environment-dependent preferences among tabular initializers: LOGQInit performs best on MountainCar and slightly best on Acrobot, whereas UCOI performs best on CartPole. This suggests that, in this line of work, DQInit names a transferable value prior plus a knownness-governed handoff from prior to learner.

4. Initialization in decentralized second-order optimization

In decentralized optimization, DQInit is not the title of a standalone algorithm but a useful label for initialization rules in DQM and DQN families. In “Decentralized Quadratically Approximated Alternating Direction Method of Multipliers,” the DQM method replaces the exact DADMM primal solve with a quadratic approximation of the local objective and requires structured initial conditions to obtain the compact primal-dual iteration (Mokhtari et al., 2015). The paper’s Assumption 3 requires $4.31$4, $4.31$5, and $4.31$6; a simple admissible initialization is $4.31$7, $4.31$8, $4.31$9, and $4.24$0, which implies $4.24$1. The practical interpretation given in the supplied material is that one chooses a primal guess $4.24$2, typically zero or a local heuristic, and sets dual variables to zero.

The role of this initialization is structural rather than predictive. Under the smoothness assumptions and these initial conditions, DQM is equivalent to a node-local update involving $4.24$3, and its global linear convergence factor asymptotically matches that of DADMM (Mokhtari et al., 2015). The initialization therefore guarantees implementability and theoretical equivalence of the compact distributed form.

A related but different usage appears in the DQN family of “Newton-like method with diagonal correction for distributed optimization” (Bajovic et al., 2015). There, each node initializes $4.24$4, chooses algorithmic parameters $4.24$5, $4.24$6, $4.24$7, and $4.24$8, and sets the diagonal correction according to the chosen variant: DQN-0 fixes $4.24$9, DQN-2 computes $1.6$0 each iteration via a local Taylor-based rule, and DQN-1 computes $1.6$1 using DQN-2 at $1.6$2 and then freezes it for all later iterations. The initialization is thus part of the approximation architecture of the inverse Hessian rather than merely a starting point.

The 2024 multi-agent “Distributed Quasi-Newton Method” adopts yet another initialization pattern (Shorinwa et al., 2024). Each agent initializes $1.6$3, sets $1.6$4, and chooses a positive-definite quasi-Newton matrix such as $1.6$5 or $1.6$6. Positive definiteness is emphasized because it guarantees well-defined descent directions or well-conditioned local KKT systems. Across these decentralized methods, “DQInit” therefore refers to admissible primal-dual initialization, curvature initialization, or diagonal-correction initialization rather than to transferred semantic priors.

5. DQInit-like training in quantization-aware distillation

“DQ-Whisper: Joint Distillation and Quantization for Efficient Multilingual Speech Recognition” does not name a module DQInit, but the supplied material explicitly interprets its single-stage student adaptation as a DQInit-like regime (Shao et al., 2023). The setting is Whisper compression with a whisper-small teacher and whisper-base or whisper-tiny students. The framework combines prediction-layer distillation, hidden-layer distillation with dynamic or restrained dynamic matching, and 8-bit quantization of all student decoder linear layers.

The hidden-layer mapping is dynamic:

$1.6$7

with Restrained Dynamic Matching adding monotonicity constraints $1.6$8 and $1.6$9. Quantization-aware distillation replaces purely feature-based matching with a quantization-guided mapping

$$Q_{\text{init}} = \text{FC}(\text{GlobalAvgPool}(M)).$$0

and the total loss is

$$Q_{\text{init}} = \text{FC}(\text{GlobalAvgPool}(M)).$$1

The student starts from existing Whisper checkpoints and is then trained in a single-stage joint distillation-plus-quantization schedule.

Because the paper does not explicitly call this stage DQInit, any extension of the term here is interpretive. A defensible reading is that the student is initialized and adapted under teacher guidance and quantization constraints from the start, rather than undergoing a pure-KD phase followed by a separate quantization phase. Empirically, this regime achieves up to $$Q_{\text{init}} = \text{FC}(\text{GlobalAvgPool}(M)).$$2 reduction in model size with marginal performance degradation, and the tiny model reaches $$Q_{\text{init}} = \text{FC}(\text{GlobalAvgPool}(M)).$$3 compression in the reported Chinese setup (Shao et al., 2023). This suggests a broader use of DQInit as initialization-through-joint-transfer rather than as a fixed architectural block.

6. Common structure, differences, and recurring misconceptions

A common pattern across these uses is the introduction of informative priors before ordinary iterative refinement takes over. In facial landmark detection, the prior is image-conditioned and acts at inference time through $$Q_{\text{init}} = \text{FC}(\text{GlobalAvgPool}(M)).$$4 derived from backbone memory (Jin et al., 2021). In deep RL, the prior is task-transfer based and is phased out locally through a knownness gate (Mehimeh, 12 Aug 2025). In decentralized optimization, initialization is structural, ensuring feasibility, positive definiteness, or distributed implementability rather than transferring semantic knowledge (Mokhtari et al., 2015, Bajovic et al., 2015, Shorinwa et al., 2024). In the DQ-Whisper interpretation, initialization is effectively training-regime based, because quantization and distillation shape the student from the outset (Shao et al., 2023).

A frequent misconception is to treat DQInit as the name of one method family with a stable technical definition. The literature represented here does not support that interpretation. The same label can refer to query initialization in a transformer decoder, value-function initialization in deep RL, or admissible initialization in decentralized second-order methods. A plausible implication is that DQInit functions more as a methodological motif—injecting structured prior information early—than as a single algorithmic object.

Another misconception is that initialization is only relevant at the first iteration. The reviewed usages show several alternatives. Facial-landmark DQInit is recomputed from each input image; RL DQInit continues to affect decisions until local knownness grows; DQN-1 freezes a diagonal correction estimated at $$Q_{\text{init}} = \text{FC}(\text{GlobalAvgPool}(M)).$$5; and DQM’s initialization determines whether the compact distributed form is valid throughout the run. This suggests that, in current research usage, DQInit often denotes an initialization mechanism whose effect persists beyond initialization in the narrow temporal sense.