An Extension of Laor Weight Initialization for Deep Time-Series Forecasting: Evidence from Thai Equity Risk Prediction

Abstract

This study presents a gradient-informed proxy initialization framework designed to improve training efficiency and predictive performance in deep learning models for time-series forecasting. The method extends the Laor Initialization approach by introducing backward gradient norm clustering as a selection criterion for input-layer weights, evaluated through a lightweight, architecture-agnostic proxy model. Only the numerical input layer adopts the selected initialization, while internal components retain standard schemes such as Xavier, Kaiming, or Orthogonal, maintaining compatibility and reducing overhead. The framework is evaluated on a real-world financial forecasting task: identifying high-risk equities from the Thai Market Surveillance Measure List, a domain characterized by label imbalance, non-stationarity, and limited data volume. Experiments across five architectures, including Transformer, ConvTran, and MMAGRU-FCN, show that the proposed strategy improves convergence speed and classification accuracy, particularly in deeper and hybrid models. Results in recurrent-based models are competitive but less pronounced. These findings support the method’s practical utility and generalizability for forecasting tasks under real-world constraints.

1. Introduction

Deep learning methods have achieved substantial success in time-series forecasting tasks across various domains, including retail sales [1], sports outcomes [2], and urban traffic dynamics [3], due to their capacity to model nonlinear dependencies and multiscale temporal patterns. Despite their capabilities, deep neural networks remain sensitive to initial weight configurations, which can significantly influence optimization behavior, predictive stability, and convergence rates, particularly in deep or resource-constrained forecasting pipelines [4].

Widely adopted initialization schemes such as Xavier [5], Kaiming [6], and Orthogonal initialization [7], are valued for their variance-preserving properties but remain inherently data-agnostic. In non-stationary or class-imbalanced settings, these approaches often require prolonged optimization phases to achieve task-relevant representations [8]. Data-driven alternatives, such as Layer-Sequential Unit Variance (LSUV) [9] and Laor Initialization [10], introduce empirical feedback to guide weight selection, often resulting in improved early convergence. However, these methods typically increase computational complexity and are sensitive to model-specific engineering constraints. This limits their scalability across diverse forecasting architectures and operational settings.

Despite their limitations, data-driven initialization methods such as LSUV and Laor often improve convergence behavior, but they also increase computational burden and are less flexible across architectures. Yet, in real-world financial forecasting scenarios, particularly those involving regulatory monitoring, even modest gains in training efficiency or classification accuracy can be consequential. This is especially true in emerging markets like Thailand, where timely detection of high-risk securities directly affects investor protection and market integrity [11,12,13,14,15].

To address these limitations, this study proposes a selective, proxy-assisted initialization framework that extends Laor Initialization using backward gradient norm clustering. The approach applies custom initialization only at the numerical input layer—where parameter sensitivity is highest—while retaining conventional methods for internal layers. A lightweight linear proxy model is used to evaluate candidate weight sets, enabling gradient-informed selection without modifying the forecasting architecture.

The method is empirically evaluated on five deep learning models, Transformer [16], ConvTran [17], MLSTM-FCN [18], MALSTM-FCN, and MMAGRU-FCN [19], using a real-world forecasting task: identifying at-risk stocks in the Stock Exchange of Thailand (SET) based on the Market Surveillance Measure List (MSML). This task exemplifies structural challenges such as class imbalance, temporal drift, and high retraining frequency, making it a representative benchmark for evaluating initialization methods in practical forecasting pipelines.

The remainder of this paper is organized as follows. Section 2 reviews forecasting models, conventional weight initialization schemes, and data-driven approaches, highlighting their limitations in real-world pipelines. Section 3 presents the proposed proxy-assisted, gradient-informed initialization framework, together with the evaluation process and experimental setup. Section 4 reports empirical results across five deep learning architectures, analyzing convergence, efficiency, and computational overhead. Section 5 provides a combined discussion and conclusion, outlining key findings, practical implications, and directions for future research.

2. Background and Related Works

2.1. Forecasting Models and Their Challenges

Forecasting problems have traditionally been addressed with statistical models such as ARIMA [20] and GARCH [21], which provide interpretable predictions but struggle with nonlinear and multivariate dynamics. Classical machine learning models such as Support Vector Machines [22] and Random Forests [23] reduce these limits but require heavy feature engineering and cannot easily model sequential dependencies.

Recent advances in deep learning have greatly improved time-series forecasting. Foundational models such as Recurrent Neural Networks (RNNs) [24], along with Long Short-Term Memory (LSTM) networks [25], and Gated Recurrent Units (GRUs) [26] capture sequential dependencies directly from raw or minimally processed data. Convolutional Neural Networks (CNNs) [27] can also extract local temporal features. More recently, Transformer-based architectures [16] enable parallel processing and long-range dependencies through attention mechanisms.

While RNNs and their gated extensions laid the foundation for sequence modeling, Transformers improved scalability and expressiveness. Hybrid architectures (e.g., MLSTM-FCN, ConvTran) combine convolutional, recurrent, or attention components to balance local feature extraction with long-term dependency learning. Despite their effectiveness, performance remains sensitive to depth, regularization, and weight initialization.

This study does not aim to solve domain challenges such as non-stationarity [28], class imbalance [29], or cold start [30]. Instead, it builds on the validated forecasting pipeline proposed by Petchpol and Boongasame (2025) [31], which addresses these through principled design: preventing data leakage with strict sequence inputs [20]; mitigating non-stationarity via rolling window [32]; handling cold starts with implicit transfer learning [31]; and correcting class imbalance with SMOTE [33].

The pipeline benchmarks classical baselines (Random Walk [34], Random Forest, LSTM, GRU), which proved insufficient under real-world constraints. Final evaluation therefore centers on five deep learning architectures—Transformer, ConvTran, MLSTM-FCN, MALSTM-FCN, and MMAGRU-FCN—demonstrating superior robustness and predictive performance. This diverse set of architectures establishes a reliable foundation for isolating the impact of weight initialization, a sensitive hyperparameter that strongly influences convergence speed, training stability, and forecasting accuracy. The following sections examine its role and review existing strategies in support of a more effective initialization approach.

2.2. Conventional Weight Initialization Methods

Weight initialization plays a foundational role in the training dynamics of deep neural networks [35]. Conventional strategies such as Xavier initialization, Kaiming initialization, and Orthogonal initialization are widely adopted for their theoretical soundness and empirical effectiveness across a range of architectures [8]. Xavier initialization preserves variance across layers under symmetric activation functions such as tanh and sigmoid [5]. Kaiming initialization adjusts the variance for rectified linear units (ReLU), mitigating vanishing gradients in deeper networks [6]. Orthogonal initialization, particularly useful in recurrent structures, maintains signal norms across time steps, supporting stable temporal learning [7].

These methods are computationally efficient and architecture-compatible, which contributes to their widespread use in both research and production systems. Modern deep forecasting models, including LSTM and Transformers, like their predecessors RNNs and CNNs, continue to rely on these initialization schemes due to their compatibility with common training pipelines.

However, these strategies are inherently data-agnostic and do not incorporate information from the input distribution or task objective. As a result, they require additional optimization effort before network parameters converge toward task-relevant representations, which can prolong training time and, in some cases, lead to suboptimal convergence, particularly in forecasting tasks with limited data, non-stationarity, or shifting distributions.

2.3. Data-Driven Initialization Approaches and Limitations

To overcome the limitations of traditional data-agnostic schemes, several data-driven initialization methods have been proposed to incorporate distributional and task-specific information from the training data. Among these, Layer-Sequential Unit-Variance (LSUV) initialization improves training stability by performing forward passes to normalize the output variance of each layer sequentially [9]. LSUV requires minimal tuning and offers improved convergence, particularly in deep architectures.

Laor Initialization introduces a distinct data-driven approach that evaluates multiple randomly sampled weight candidates at the input layer using forward-pass loss as a proxy for optimization readiness [10]. The method clusters the resulting loss scores and selects the candidate associated with the most promising cluster, aiming to improve early convergence and final predictive performance. Unlike LSUV, which normalizes layer activations, Laor Initialization emphasizes loss-informed clustering to guide initialization. This design is particularly suited for tasks characterized by temporal variability and label imbalance, where early training stability can significantly affect downstream performance.

Despite their conceptual strengths, both LSUV and Laor Initialization face practical limitations. Because they rely on multiple forward passes for either activation normalization or loss-based candidate evaluation, they introduce additional computational overhead at the initialization stage. Furthermore, both methods are tightly coupled with specific model architectures. Adapting them to newer or more complex designs, such as Transformers, hybrid attention networks, or modular architectures, often requires extensive code customization and access to internal layers. This combination of computational and engineering overhead reduces their usability in heterogeneous forecasting pipelines, where efficiency and model flexibility are essential. These limitations motivate the development of more architecture-agnostic, reusable, and lightweight initialization strategies.

2.4. Toward Optimization-Aware and Architecture-Agnostic Initialization

While data-driven initialization methods offer task-informed starting points, applying them across all layers of a deep model introduces significant computational and engineering overhead. Each layer typically requires specialized access for forward or gradient evaluation, complicating their integration into diverse or modular architectures. In practice, the input layer, where raw temporal signals first interact with the model, is often the most accessible and initialization-sensitive component.

These considerations highlight the value of a selective hybrid strategy: applying data-informed initialization where it is most impactful—which, in our case, is the input layer—while retaining conventional, efficient initializers for internal components such as attention mechanisms or recurrent blocks. As discussed in the previous section, most existing data-driven methods rely on forward-pass loss to select among candidate weight configurations and are often tightly coupled to specific architectural designs. This limits their usability in dynamic forecasting pipelines that demand both architectural flexibility and computational efficiency.

Consequently, there is a clear need for an initialization strategy that is both optimization-aware and architecture-agnostic, one that can evaluate candidate weights in a task-relevant manner without requiring deep structural access or significant engineering integration. The present study addresses this need by introducing a novel proxy-assisted gradient-informed approach, which is formally described in Section 3.

2.5. Relevance to Forecasting: A Case Study in the Thai Equity Market

Financial time-series forecasting is a technically demanding task characterized by non-stationarity, class imbalance, limited historical data, and dynamic structural shifts. These characteristics increase sensitivity to model configuration choices such as architecture depth, training frequency, and weight initialization. The Thai equity market provides a particularly suitable testbed. In this setting, the Stock Exchange of Thailand (SET) implements a Market Surveillance Measure List (MSML) to flag stocks with abnormal price and volume behavior [11], aiming to protect investors from market manipulation or excessive speculation [11,12,13,14,15].

Forecasting which stocks are likely to be flagged in advance poses a complex classification problem under regulatory, temporal, and data-driven constraints. The problem is further challenged by the infrequent and imbalanced nature of MSML events, the diversity of financial instruments, and the requirement of retraining across evolving time windows. To support experimentation, this study adopts the forecasting pipeline of Petchpol and Boongasame (2025) [31], which handles data leakage, concept drift, class imbalance, and cold start conditions.

While the focus of this work is on financial risk prediction, the challenges of non-stationarity, label imbalance, heterogeneous architectures, and retraining are also common in energy demand forecasting [36], epidemiological trend detection [37], and environmental monitoring [38], where similar pressures on model reliability and efficiency exist. Thus, this case study offers broader insight into the behavior of deep forecasting models under real-world operational constraints.

3. A Hybrid Weight Initialization Framework

3.1. Proxy Model

The proposed framework introduces a selective weight initialization strategy that targets only the numerical input layer, where initialization sensitivity is most pronounced in deep time-series forecasting models. Rather than applying complex initialization schemes across the entire architecture, this design seeks to balance optimization-awareness with architectural simplicity and computational efficiency.

To achieve this, the framework employs a lightweight proxy model that evaluates multiple candidate weight configurations prior to training. The proxy serves as a surrogate for the full forecasting architecture, enabling architecture-agnostic evaluation while keeping computational cost low. This design decouples initialization assessment from internal model structures, making it fully generalizable and applicable across a wide range of deep learning architectures.

The proxy itself is implemented as a single-layer linear transformation, followed by a task-specific output head. For classification tasks such as Market Surveillance Measure List (MSML) prediction, the output head is a softmax classifier trained using cross-entropy loss defined as:

$$\mathcal{L}=-\sum _{i=1}^C{y}_i\log \left({\widehat{y}}_i\right),$$

(1)

where $C$ is the number of classes, $y_i$ represents the true label, and ${\widehat{y}}_i$ is the predicted probability for class $i$. In our MSML task, which is binary (flagged vs. not flagged), this categorical cross-entropy naturally reduces to the binary cross-entropy where $C=2$, with $y_1$ representing the probability of ‘not flagged’ and $y_2$ representing the probability of ‘flagged’. For regression settings, it is replaced with a linear output trained via mean squared error:

$$\mathcal{L}= \sum _{j=1}^S{\left(y_j - {\widehat{y}}_j\right)}^2,$$

(2)

where $S$ is the number of samples, $y_j$ is the true target value for sample $j$, and ${\widehat{y}}_j$ is the predicted value.

As illustrated in Figure 1, categorical inputs are processed separately using a standard Xavier-initialized embedding layer, while the proxy-based initialization is applied exclusively to the numerical input layer. The remainder of the forecasting architecture, including models such as Transformer, ConvTran, MLSTM-FCN, MALSTM-FCN, and MMAGRU-FCN, is adopted from the validated pipeline of Petchpol and Boongasame (2025) and used without modification [31]. These internal layers retain a standardized initialization policy based on each layer’s structure and activation behavior (summarized in

Table 1. Initialization policy by layer type and functional role across all architectures.

Layer Type	Typical Usage	Initialization Method	Rationale
Numerical input layer	Input embedding for continuous features	Gradient-Informed (Proposed)	Sensitive to input scale; proxy-based optimization-aware selection
Category embedding layer	Discrete feature embedding (e.g., symbols)	Xavier	Symmetric activation; standard for embedding weights
Linear layers	Attention, classifiers, residual paths	Xavier or Kaiming (depending on activation)	Preserves variance across layers
ReLU-activated convolutional layers	Temporal/spatial convolutions	Kaiming	Designed for ReLU; prevents vanishing gradients
GRU/LSTM input weights	Input-to-hidden recurrence	Xavier	Balanced signal propagation
GRU/LSTM recurrent weights	Hidden-to-hidden recurrence	Orthogonal	Preserves long-term dependencies across time steps
Bias terms	All layers with bias	Zeros	Ensures no unintended initial activation bias

), allowing the effect of the proposed method to be evaluated in isolation.

Importantly, the proxy is not discarded after evaluation. The selected weight configuration is retained and used to initialize the input layer of the actual forecasting model. This ensures that initialization reflects real data flow characteristics while avoiding overhead from repeated or full-model training. The following section introduces a data-driven evaluation procedure designed to guide this selection process, using empirical feedback from the proxy to identify initialization configurations that are more responsive to the forecasting task at hand.

3.2. Gradient-Informed Evaluation

The evaluation mechanism employed by the proxy builds on Laor Initialization (Laor-ori), which scores candidate weight configurations based on forward-pass classification loss. A pool of $N$ randomly generated candidate weight matrices is created for the numerical input layer. Each candidate is assigned to the proxy model and evaluated using the task-specific loss function, resulting in scalar error values (Algorithm 1). The proxy model applies these loss functions systematically across all candidate weight configurations. For classification tasks, Equation (1) is used, while regression applications would employ Equation (2).

Algorithm 1 Laor-ori (error-driven via proxy)

Input: Model $M$, proxy layer $P$, dataset batch $(X, y)$, number of candidates $N$, number of clusters $k$, loss function $\mathcal{L}$ (e.g., Cross-Entropy). Output: Model $M^{\prime }$ with proxy layer $P^{\prime }$. Begin: Define a standalone proxy layer $W_i\in {\mathbb{R}}^{d_{\mathrm{out}}\times d_{\mathrm{in}}}$ with dimensions matching $P$, where $d_{\mathrm{in}}$ and $d_{\mathrm{out}}$ denote the input and ouput dimensionalities of the layer under consideration. Randomly generate $N$ normal distributed candidate weight matrices:                   $\left\{W_1, W_2, \dots , W_N\right\}$. For each candidate $W_i$:      a. Assign $W_i$ to $P$.      b. Perform forward pass: $\widehat{y_i}=P\left(X\right).$      c. Compute scalar loss/error: ${\mathsf{\ell }}_i=\mathcal{L}\left(\widehat{y_i},y\right)$. Form the error set: $E=\left\{{\mathsf{\ell }}_1, {\mathsf{\ell }}_2, \dots , {\mathsf{\ell }}_N\right\}$. Cluster $E$ into $k$ clusters using k-means. Identify cluster $C^{*}$ with the lowest mean error. Average weights from all candidates in $C^{*}$:               $W_{\mathrm{final}}={\displaystyle \frac{1}{\left|C^{*}\right|}}{\displaystyle \sum _{w_i\in C^{*}}}{W}_i.$ Assign $W_{\mathrm{final}}$ to $P$.

The proposed gradient-informed Laor variant (Laor) improves upon this by replacing the loss-based evaluation with the $l_2$-norm of the backward gradients of each candidate (Algorithm 2). The gradient norm for candidate $i$ is computed as:

$$g_i ={ ‖{\nabla }_{W_i}{\mathsf{\ell }}_i‖}_2,$$

(3)

where $W_i$ denotes the candidate weight matrix in the proxy layer and ${\mathsf{\ell }}_i$ is the corresponding scalar loss. This measure provides a direct and actionable indicator of optimization potential, unlike the loss value alone.

Algorithm 2 Laor (gradient-informed via proxy)

Input: Model $M,$ proxy layer $P$, Optimizer $\mathcal{O}$ (e.g., SGD, Adam), dataset batch $(X, y)$, number of candidates $N$, number of clusters $k$, loss function $\mathcal{L}$ (e.g., Cross-Entropy), randomizer $\mathcal{R}$: a base weight initializer (e.g., Random, Kaiming-Normal). Output: Model $M^{\prime }$ with proxy layer $P^{\prime }$. Begin: Define a standalone proxy layer $W_i\in {\mathbb{R}}^{d_{\mathrm{out}}\times d_{\mathrm{in}}}$ with dimensions matching $P$, where $d_{\mathrm{in}}$ and $d_{\mathrm{out}}$ denote the input and ouput dimensionalities of the layer under consideration. Generate $N$ candidate weight matrices using randomizer $\mathcal{R}$:             $\left\{W_1, W_2, \dots , W_N\right\}, W_i~\mathcal{R}.$ For each candidate $W_i$:      a. Assign $W_i$ to $P$.      b. Zero gradients in optimizer $\mathcal{O}$.      c. Perform forward pass: $\widehat{y_i} = P\left(X\right)$.      d. Compute scalar loss value: ${\mathsf{\ell }}_i=\mathcal{L}(\widehat{y_i},y)$.      e. Perform backward pass and compute gradient $l_2$-norm:                  $g_i={‖{\nabla }_{W_i}{\mathsf{\ell }}_i‖}_2$ Form the gradient norm set: $G=\left\{g_1, g_2, \dots , g_N\right\}$. Cluster the $G$ into $k$ clusters using k-means. Identify cluster $C^{*}$ with the highest mean gradient norm. Average weights from all candidates in $C^{*}$:               $W_{\mathrm{final}}={\displaystyle \frac{1}{\left|C^{*}\right|}}{\displaystyle \sum _{w_i\in C^{*}}}{W}_i.$ Assign $W_{\mathrm{final}}$ to $P$.

To demonstrate this advantage, consider the gradient descent update rule in Equation (4). If one were to take a step of size $\eta$, the expected first-order decrease for candidate $i$ would be

$${∆\mathsf{\ell }}_i \approx -\eta g_i^2.$$

(4)

• The key distinction between approaches lies in their selection criteria:
• Laor-ori (Algorithm 1). Selects candidates by ${\mathsf{\ell }}_i$ Smaller loss values indicate lower initial misfit but do not guarantee faster optimization.
• Laor (Algorithm 2). Selects candidates by $g_i$ Larger gradient norms imply greater reduction potential per update step, aligning initialization with optimization dynamics rather than only initial fit quality.

Both methods apply k-means clustering followed by averaging within the best cluster. This design, inherited from the original Laor method, improves reproducibility and reduces sensitivity to noise or outliers, ensuring that initialization is not determined by a single potentially unstable candidate but instead reflects a more robust consensus of promising weights.

Finally, to evaluate the robustness and variability of the proposed method, multiple gradient-informed Laor variants are explored, each differing in their random initialization schemes:

• Laor-n/Laor-u: Laor with normal/uniform distribution sampling;
• Laor-kn/Laor-ku: Laor with Kaiming Normal/Kaiming Uniform sampling;
• Laor-xn/Laor-xu: Laor with Xavier Normal/Xavier Uniform sampling;
• Laor-o: Laor with orthogonal matrix sampling.

3.3. Experimental Setup

This section describes the experimental setup used to evaluate the proposed proxy-assisted, gradient-informed initialization framework. The experiments are conducted within a multivariate time-series classification (MTSC) setting and build directly on a previously validated pipeline developed by Petchpol and Boongasame (2025) [31]. All model configurations, training routines, and evaluation metrics are held constant across experiments to isolate the impact of the weight initialization strategy.

3.3.1. Inherited Setup from Prior Work

• Dataset: Daily end-of-day (EOD) stock trading data and Market Surveillance Measure List (MSML) labels were obtained from the SET Market Analysis and Reporting Tool (SETSMART) platform [39], covering the period from 16 November 2012 to 15 June 2024. The dataset includes adjusted closing prices, trading volumes, valuation ratios (P/E, P/BV), and derived technical and sentiment indicators. Each record is associated with a binary label indicating whether the corresponding equity appears on the MSML;
• Preprocessing Steps: Temporal alignment was strictly maintained by using predictors at time $t$ exclusively derived from historical observations up to $t - 1$. Forecasting labels were forward-shifted according to the forecasting horizon. Numerical features underwent standardization and precision rounding to six decimal places to enhance training stability. Missing trading values for suspended stocks were explicitly imputed with zeros, indicating absence of trading activity;
• Rolling Window Training Strategy: A rolling window methodology was used to handle temporal non-stationarity, employing a training window of 1260 trading days (~5 years), a validation window of 60 trading days (~1 quarter), and a rolling step size of 60 days. This strategy resulted in 26 training-validation cycles for each experimental iteration;
• Class Imbalance Handling: Given the significant minority class imbalance (~3.6% positive samples), Synthetic Minority Oversampling Technique (SMOTE) was applied within each rolling training window, doubling minority instances via interpolation with 5-nearest neighbors;
• Computational Environment: Experiments were executed using PyTorch version 2.3.0 on an NVIDIA RTX 3090 GPU (NVIDIA Corporation, Santa Clara, CA, USA), Intel i7-13700KF CPU (Intel Corporation, Santa Clara, CA, USA), and 32 GB RAM, with CUDA version 12.3, ensuring reproducibility and computational efficiency;
• Evaluation Metrics: The primary evaluation metric was Matthews Correlation Coefficient (MCC), complemented by supplementary metrics including F1 score, Recall, Precision, Accuracy, and Cross-Entropy Loss. Computational efficiency metrics encompassed training time per epoch, total wall-clock time, and epochs to convergence;
• Model Architectures: Five deep learning models are used, spanning a range of structural patterns from fully attention-based to recurrent-convolutional hybrids as in

  Table 2. Forecasting architectures used in the evaluation and their structural characteristics.

  Model	Description
  Transformer	Attention-only architecture [16]
  ConvTran	CNN-Transformer hybrid [17]
  MLSTM-FCN	Multivariate LSTM with fully convolutional classifier [18]
  MALSTM-FCN	Attention-augmented MLSTM-FCN
  MMAGRU-FCN	Memory–attention–GRU hybrid with CNN feature extractor [19]

  Note: Architectures and descriptions are based on prior configurations from Petchpol and Boongasame (2025) without modification [31].

  .
• Hyperparameters: Training configurations were inherited directly from prior work and remained fixed across all initialization experiments. These hyperparameters, summarized in

  Table 3. Model-specific hyperparameter configurations.

  Model	Learning Rate	Dropout	Weight Decay	Sequence Length	Hidden Dim	FF Dim	Heads	Emb. Dim	Layers	CNN Dim
  Transformer	0.0001	0.5	0.01	28	–	32	2	4	1	–
  ConvTran	0.0001	0.7	0.001	56	–	4	2	4	1	8
  MLSTM-FCN	0.0001	0.8	0.001	14	32	–	–	–	1	8
  MALSTM-FCN	0.0001	0.8	0.01	14	32	–	–	–	1	16
  MMAGRU-FCN	0.00001	0.5	0.001	7	64	–	–	–	3	64

  Note: Hyperparameter values are retained from Petchpol and Boongasame (2025) without modification [31]. Definitions—FF Dim: hidden dimension of the feed-forward network in Transformer/ConvTran blocks; Emb. Dim: embedding dimension of input representations; CNN Dim: number of convolutional filters in convolutional modules.

  , were tuned previously and reused to ensure a controlled evaluation setting.

For further details regarding data properties, exploratory statistics, and baseline model performance, please refer to Section 3, Section 4 and Section 5 of the original study.

3.3.2. Novel Experimental Components

This study introduces a systematic evaluation of weight initialization strategies, with particular emphasis on the proposed proxy-assisted gradient-informed Laor initialization. The following components were developed to extend the baseline forecasting framework and isolate the contribution of the initialization method.

• Initialization Strategies Compared: Seventeen initialization strategies were evaluated at the numerical input layer, grouped into four categories (A comparative summary is provided in

  Table 4. Comparative summary of weight initializer candidates. Baseline methods (Xavier, Kaiming, Normal, Uniform, Orthogonal, LSUV, Laor-ori) represent established approaches from the literature, while the gradient-informed Laor variants (Laor, Laor-n, Laor-u, Laor-kn, Laor-ku, Laor-xn, Laor-xu, Laor-o) represent the novel contribution of this study.

  Group	Initializers	Description
  Data-agnostic baseline	Xavier-Normal/Uniform, Kaiming-Normal/Uniform, Normal, Uniform, Orthogonal	Commonly used baselines relying only on fan-in/out and variance scaling without data or label information
  Data-driven method
  Variance-based	LSUV	Initialization based on layer-sequential unit variance using activation statistics
  Error-driven (original Laor)	Laor-ori	Reimplementation of the original Laor method using k-means clustering on forward-pass loss values
  Gradient-informed (Laor variants)	Laor, Laor-n, Laor-u, Laor-kn, Laor-ku, Laor-xn, Laor-xu, Laor-o	Variants of Laor Initialization using gradient norms during clustering, evaluated through a proxy layer and fixed across training

  ):

• Traditional data-agnostic methods: Xavier (Uniform, Normal), Kaiming (Uniform, Normal), Random (Uniform, Normal), and Orthogonal.
• Variance-based method: Layer-Sequential Unit Variance (LSUV).
• Error-driven method: Original Laor Initialization, using clustering on forward-pass loss values.
• Gradient-informed variants (proposed): Laor, Laor-Normal (Laor-n), Laor-Uniform (Laor-u), Laor-Kaiming-Normal (Laor-kn), Laor-Kaiming-Uniform (Laor-ku), Laor-Xavier-Normal (Laor-xn), Laor-Xavier-Uniform (Laor-xu), Laor-Orthogonal (Laor-o). All use the same gradient-norm clustering scheme and differ only in the randomization method used to generate candidate weights.

These strategies are applied solely at the input layer; internal layers follow fixed initializers based on their architecture and activation type (as described in Table 1). This separation isolates the impact of input-layer initialization while maintaining compatibility with diverse architectures.

• Proxy-Layer and Clustering Procedure: Each strategy is evaluated through the same proxy model described in Section 3.1 and 3.2. For gradient-informed variants, $N=10$ weight candidates are generated using the assigned randomizer, evaluated by gradient norm, and clustered using k-means with $k=2$. The choice of $N=10$ follows the established methodology from the original Laor initialization paper, ensuring methodological consistency and comparability with prior work. The parameter $k=2$ aligns with the binary classification structure of our forecasting task (flagged vs. not flagged stocks), providing a natural clustering framework for candidate selection. The final weight is computed by averaging the members of the lowest-gradient cluster. The same clustering process is used for the error-driven variant, except based on forward-pass loss. All candidates are evaluated under identical proxy conditions to ensure fair comparison.
• Statistical Robustness Checks: To assess the robustness of each strategy, every experimental configuration was repeated 20 times with independent random seeds. Aggregate statistics, including mean performance, standard deviation, and training time, were reported for each model-initializer combination, allowing for comprehensive comparison of predictive accuracy and convergence efficiency.

3.4. Experiment Summary

All experiments in this study are conducted within a previously validated deep time-series forecasting pipeline, incorporating safeguards against data leakage, concept drift, class imbalance, and cold-start scenarios. These aspects are addressed through sequence-based input design, rolling-window training, SMOTE-based oversampling, and implicit transfer learning.

Five deep learning architectures, Transformer, ConvTran, MLSTM-FCN, MALSTM-FCN, and MMAGRU-FCN, are retained from prior work, in which they demonstrated strong and consistent performance for multivariate time-series classification. These configurations were previously identified as the most effective under real-world forecasting constraints.

No architectural or training modifications are introduced in this study. All preprocessing steps, hyperparameters, and training routines are preserved to ensure consistency with the original pipeline, thereby isolating the impact of weight initialization.

Only the initialization strategy at the numerical input layer is varied. This setup ensures that any observed variation in performance or training efficiency, as reported in Section 4, can be attributed solely to the effect of weight initialization.

4. Results

This section presents empirical results evaluating the proposed gradient-informed initialization strategies against traditional, variance-based, and error-driven methods. All evaluations are conducted within the controlled forecasting pipeline described in Section 3, using five deep learning architectures selected from prior work. To ensure statistical robustness, each model–initializer configuration is trained over 20 independent runs. Evaluation focuses on three key dimensions: (1) baseline performance comparison on the Transformer model, (2) generalizability across diverse architectural types, and (3) convergence speed and computational efficiency. Full classification and convergence metrics are provided in Appendix A 

Table A1. Classification metrics for weight initializers on the Transformer model. Metrics include Accuracy, Precision, Recall, F1 Score, and MCC on the test set.

Group	Weight Initializer	Test Accuracy (%)	Test Precision (%)	Test Recall (%)	Test F1 Score (%)	Test MCC (%)
Traditional	Kaiming-Normal	84.30 ± 0.55	81.84 ± 0.82	88.39 ± 0.97	84.98 ± 0.52	68.82 ± 1.09
(Data-agnostic baseline)	Kaiming-Uniform	84.23 ± 0.69	81.77 ± 0.90	88.33 ± 1.11	84.92 ± 0.66	68.69 ± 1.39
	Xavier-Normal	84.30 ± 0.55	81.84 ± 0.82	88.39 ± 0.97	84.98 ± 0.52	68.82 ± 1.09
	Xavier-Uniform	84.23 ± 0.69	81.77 ± 0.90	88.33 ± 1.11	84.92 ± 0.66	68.69 ± 1.39
	Normal	85.22 ± 0.50	84.02 ± 0.58	87.19 ± 1.28	85.57 ± 0.57	70.51 ± 1.02
	Uniform	84.33 ± 0.45	82.61 ± 0.70	87.19 ± 1.31	84.83 ± 0.51	68.77 ± 0.94
	Orthogonal	84.25 ± 0.58	81.70 ± 1.06	88.52 ± 0.95	84.96 ± 0.48	68.75 ± 1.08
Data-driven method
Variance-based	LSUV	85.20 ± 0.39	84.11 ± 0.90	87.02 ± 1.44	85.53 ± 0.45	70.47 ± 0.80
Error-driven (original Laor)	Laor-ori	84.14 ± 0.55	81.49 ± 0.86	88.56 ± 0.92	84.88 ± 0.50	68.53 ± 1.07
Gradient-informed	Laor	84.71 ± 0.69	83.69 ± 1.77	86.54 ± 2.33	85.05 ± 0.69	69.54 ± 1.31
(Laor variants)	Laor-kn	84.04 ± 0.58	81.96 ± 1.27	87.55 ± 1.88	84.64 ± 0.61	68.27 ± 1.16
	Laor-ku	83.97 ± 0.62	81.52 ± 0.68	88.06 ± 0.95	84.66 ± 0.61	68.15 ± 1.26
	Laor-xn	84.04 ± 0.58	81.96 ± 1.27	87.55 ± 1.88	84.64 ± 0.61	68.27 ± 1.16
	Laor-xu	83.97 ± 0.62	81.52 ± 0.68	88.06 ± 0.95	84.66 ± 0.61	68.15 ± 1.26
	Laor-n	85.05 ± 0.44	84.22 ± 1.09	86.49 ± 1.95	85.32 ± 0.58	70.16 ± 0.90
	Laor-u	84.28 ± 0.44	82.70 ± 0.41	86.91 ± 1.01	84.75 ± 0.49	68.66 ± 0.91
	Laor-o	84.29 ± 0.48	81.95 ± 0.99	88.18 ± 1.24	84.94 ± 0.44	68.79 ± 0.93

Note: Boldface indicates the top three scores for each metric. Higher values reflect better classification performance. Results are averaged over 20 runs for robustness.

,

Table A2. Convergence and initialization metrics for weight initializers on the Transformer model. Metrics include time per epoch, number of epochs, initialization duration, and total training time.

Group	Weight Initializer	Training Time per Epoch (s)	Number of Epochs	Weight Initial Time (s)	Total Training Time (s)
Traditional	Kaiming-Normal	7.505 ± 0.044	79.0 ± 5.7	0.101 ± 0.012	592.965 ± 0.250
(Data-agnostic baseline)	Kaiming-Uniform	7.508 ± 0.038	80.8 ± 8.1	0.115 ± 0.012	606.364 ± 0.312
	Xavier-Normal	9.513 ± 0.175	79.0 ± 5.7	0.097 ± 0.016	751.601 ± 0.990
	Xavier-Uniform	7.514 ± 0.039	80.8 ± 8.1	0.098 ± 0.013	606.819 ± 0.313
	Normal	9.521 ± 0.175	81.5 ± 6.6	0.080 ± 0.016	776.008 ± 1.158
	Uniform	9.529 ± 0.186	77.8 ± 6.7	0.105 ± 0.013	741.499 ± 1.240
	Orthogonal	9.581 ± 0.164	81.4 ± 8.0	0.080 ± 0.013	779.953 ± 1.305
Data-driven method
Variance-based	LSUV	9.504 ± 0.159	84.7 ± 7.1	0.134 ± 0.014	805.164 ± 1.130
Error-driven (original Laor)	Laor-ori	9.536 ± 0.175	78.5 ± 5.7	0.120 ± 0.005	748.190 ± 0.994
Gradient-informed	Laor	7.463 ± 0.074	79.4 ± 8.4	0.121 ± 0.007	592.715 ± 0.624
(Laor variants)	Laor-kn	7.508 ± 0.041	81.4 ± 5.3	0.124 ± 0.010	611.257 ± 0.218
	Laor-ku	7.515 ± 0.033	80.2 ± 4.3	0.118 ± 0.014	602.799 ± 0.144
	Laor-xn	9.533 ± 0.191	81.4 ± 5.3	0.120 ± 0.014	776.073 ± 1.010
	Laor-xu	9.490 ± 0.209	80.2 ± 4.3	0.134 ± 0.012	761.259 ± 0.897
	Laor-n	7.513 ± 0.037	78.6 ± 9.6	0.121 ± 0.016	590.652 ± 0.353
	Laor-u	9.510 ± 0.152	78.9 ± 7.2	0.123 ± 0.013	749.999 ± 1.095
	Laor-o	9.530 ± 0.163	81.3 ± 7.3	0.150 ± 0.014	774.926 ± 1.182

Note: Boldface highlights the top three results per metric. Lower values are preferred, as they indicate reduced computational cost. All results are averaged over 20 independent runs.

,

Table A3. Classification metrics for weight initializers on the ConvTran model. Metrics include Accuracy, Precision, Recall, F1 Score, and MCC on the test set.

Group	Weight Initializer	Test Accuracy (%)	Test Precision (%)	Test Recall (%)	Test F1 Score (%)	Test MCC (%)
Traditional	Kaiming-Normal	85.43 ± 1.52	86.42 ± 1.72	84.57 ± 4.91	85.37 ± 2.04	71.06 ± 2.81
(Data-agnostic baseline)	Kaiming-Uniform	85.68 ± 1.73	86.47 ± 1.67	85.06 ± 4.94	85.65 ± 2.22	71.53 ± 3.29
	Xavier-Normal	85.43 ± 1.52	86.42 ± 1.72	84.57 ± 4.91	85.37 ± 2.04	71.06 ± 2.81
	Xavier-Uniform	85.68 ± 1.73	86.47 ± 1.67	85.06 ± 4.94	85.65 ± 2.22	71.53 ± 3.29
	Normal	84.49 ± 0.86	85.08 ± 2.43	84.29 ± 4.65	84.55 ± 1.32	69.20 ± 1.69
	Uniform	85.23 ± 1.74	86.14 ± 2.07	84.54 ± 5.87	85.17 ± 2.41	70.73 ± 3.15
	Orthogonal	85.76 ± 0.84	86.81 ± 1.71	84.81 ± 3.48	85.73 ± 1.17	71.66 ± 1.59
Data-driven method
Variance-based	LSUV	84.80 ± 1.08	86.30 ± 2.20	83.32 ± 4.60	84.66 ± 1.56	69.85 ± 2.03
Error-driven (original Laor)	Laor-ori	85.21 ± 1.18	86.82 ± 1.55	83.47 ± 3.80	85.04 ± 1.54	70.59 ± 2.24
Gradient-informed	Laor	85.21 ± 1.37	85.01 ± 2.01	85.98 ± 3.43	85.43 ± 1.54	70.53 ± 2.70
(Laor variants)	Laor-kn	85.88 ± 1.21	85.83 ± 1.57	86.41 ± 3.80	86.05 ± 1.58	71.88 ± 2.23
	Laor-ku	86.27 ± 0.99	85.92 ± 1.38	87.17 ± 3.28	86.48 ± 1.26	72.62 ± 1.95
	Laor-xn	85.88 ± 1.21	85.83 ± 1.57	86.41 ± 3.80	86.05 ± 1.58	71.88 ± 2.23
	Laor-xu	86.27 ± 0.99	85.92 ± 1.38	87.17 ± 3.28	86.48 ± 1.26	72.62 ± 1.95
	Laor-n	84.64 ± 1.06	84.45 ± 1.93	85.44 ± 3.37	84.87 ± 1.27	69.40 ± 2.10
	Laor-u	85.92 ± 0.94	85.57 ± 2.17	86.96 ± 4.08	86.16 ± 1.30	72.02 ± 1.74
	Laor-o	85.34 ± 1.49	86.95 ± 1.43	83.63 ± 4.72	85.16 ± 2.00	70.89 ± 2.77

Note: Boldface indicates the top three scores for each metric. Higher values reflect better classification performance. Results are averaged over 20 runs for robustness.

,

Table A4. Convergence and initialization metrics for weight initializers on the ConvTran model. Metrics include time per epoch, number of epochs, initialization duration, and total training time.

Group	Weight Initializer	Training Time per Epoch (s)	Number of Epochs	Weight Initial Time (s)	Total Training Time (s)
Traditional	Kaiming-Normal	13.747 ± 0.065	75.8 ± 10.2	0.147 ± 0.017	1042.183 ± 0.663
(Data-agnostic baseline)	Kaiming-Uniform	13.744 ± 0.050	76.7 ± 7.6	0.117 ± 0.014	1053.605 ± 0.379
	Xavier-Normal	17.198 ± 0.131	75.8 ± 10.2	0.114 ± 0.014	1303.742 ± 1.334
	Xavier-Uniform	13.747 ± 0.051	76.7 ± 7.6	0.116 ± 0.009	1053.805 ± 0.385
	Normal	17.186 ± 0.135	75.1 ± 6.2	0.098 ± 0.014	1290.779 ± 0.841
	Uniform	17.169 ± 0.125	76.0 ± 7.1	0.097 ± 0.014	1304.916 ± 0.887
	Orthogonal	17.144 ± 0.060	75.8 ± 10.8	0.101 ± 0.017	1298.746 ± 0.650
Data-driven method
Variance-based	LSUV	17.134 ± 0.102	75.9 ± 7.1	0.112 ± 0.016	1299.713 ± 0.724
Error-driven (original Laor)	Laor-ori	17.161 ± 0.077	75.6 ± 9.2	0.135 ± 0.013	1296.674 ± 0.710
Gradient-informed	Laor	13.743 ± 0.047	73.7 ± 7.7	0.152 ± 0.013	1012.328 ± 0.363
(Laor variants)	Laor-kn	13.766 ± 0.051	74.7 ± 9.8	0.134 ± 0.012	1028.431 ± 0.500
	Laor-ku	13.758 ± 0.043	72.6 ± 7.8	0.135 ± 0.012	998.282 ± 0.335
	Laor-xn	17.173 ± 0.100	74.7 ± 9.8	0.176 ± 0.012	1283.035 ± 0.971
	Laor-xu	17.214 ± 0.128	72.6 ± 7.8	0.136 ± 0.013	1249.016 ± 1.003
	Laor-n	13.764 ± 0.048	72.6 ± 5.9	0.139 ± 0.012	998.713 ± 0.285
	Laor-u	17.180 ± 0.112	76.6 ± 8.1	0.137 ± 0.012	1315.229 ± 0.908
	Laor-o	17.174 ± 0.085	74.0 ± 5.9	0.132 ± 0.011	1270.980 ± 0.500

Note: Boldface highlights the top three results per metric. Lower values are preferred, as they indicate reduced computational cost. All results are averaged over 20 independent runs.

,

Table A5. Classification metrics for weight initializers on the MLSTM-FCN model. Metrics include Accuracy, Precision, Recall, F1 Score, and MCC on the test set.

Group	Weight Initializer	Test Accuracy (%)	Test Precision (%)	Test Recall (%)	Test F1 Score (%)	Test MCC (%)
Traditional	Kaiming-Normal	85.83 ± 1.03	86.20 ± 0.73	85.42 ± 2.02	85.80 ± 1.16	71.69 ± 2.04
(Data-agnostic baseline)	Kaiming-Uniform	85.35 ± 1.46	86.53 ± 1.02	83.88 ± 4.22	85.11 ± 1.92	70.84 ± 2.75
	Xavier-Normal	85.83 ± 1.03	86.20 ± 0.73	85.42 ± 2.02	85.80 ± 1.16	71.69 ± 2.04
	Xavier-Uniform	85.35 ± 1.46	86.53 ± 1.02	83.88 ± 4.22	85.11 ± 1.92	70.84 ± 2.75
	Normal	86.16 ± 1.03	87.81 ± 1.05	84.10 ± 2.80	85.88 ± 1.29	72.44 ± 1.94
	Uniform	85.06 ± 1.43	87.81 ± 0.97	81.57 ± 4.15	84.50 ± 1.90	70.40 ± 2.63
	Orthogonal	85.97 ± 1.19	86.46 ± 1.04	85.40 ± 2.41	85.90 ± 1.35	71.97 ± 2.36
Data-driven method
Variance-based	LSUV	86.10 ± 1.14	87.61 ± 1.19	84.21 ± 2.66	85.85 ± 1.35	72.30 ± 2.20
Error-driven (original Laor)	Laor-ori	85.20 ± 1.49	86.26 ± 1.21	83.89 ± 3.89	85.00 ± 1.85	70.52 ± 2.87
Gradient-informed	Laor	85.22 ± 1.22	87.76 ± 1.24	82.00 ± 3.62	84.73 ± 1.61	70.68 ± 2.25
(Laor variants)	Laor-kn	85.26 ± 1.35	86.71 ± 1.07	83.41 ± 3.47	84.99 ± 1.68	70.65 ± 2.58
	Laor-ku	85.13 ± 1.12	86.50 ± 1.05	83.41 ± 3.25	84.88 ± 1.46	70.38 ± 2.09
	Laor-xn	85.26 ± 1.35	86.71 ± 1.07	83.41 ± 3.47	84.99 ± 1.68	70.65 ± 2.58
	Laor-xu	85.13 ± 1.12	86.50 ± 1.05	83.41 ± 3.25	84.88 ± 1.46	70.38 ± 2.09
	Laor-n	84.74 ± 1.90	88.18 ± 1.20	80.39 ± 4.98	84.00 ± 2.56	69.88 ± 3.39
	Laor-u	85.37 ± 1.35	87.47 ± 0.77	82.69 ± 3.66	84.96 ± 1.74	70.92 ± 2.53
	Laor-o	85.72 ± 1.23	86.62 ± 0.99	84.62 ± 3.71	85.55 ± 1.60	71.54 ± 2.36

Note: Boldface indicates the top three scores for each metric. Higher values reflect better classification performance. Results are averaged over 20 runs for robustness.

,

Table A6. Convergence and initialization metrics for weight initializers on the MLSTM-FCN model. Metrics include time per epoch, number of epochs, initialization duration, and total training time.

Group	Weight Initializer	Training Time per Epoch (s)	Number of Epochs	Weight Initial Time (s)	Total Training Time (s)
Traditional	Kaiming-Normal	7.033 ± 0.045	74.0 ± 6.1	0.101 ± 0.013	520.549 ± 0.276
(Data-agnostic baseline)	Kaiming-Uniform	7.042 ± 0.054	76.2 ± 9.9	0.129 ± 0.011	536.354 ± 0.533
	Xavier-Normal	8.003 ± 0.172	74.0 ± 6.1	0.110 ± 0.009	592.341 ± 1.052
	Xavier-Uniform	7.041 ± 0.052	76.2 ± 9.9	0.098 ± 0.010	536.285 ± 0.516
	Normal	7.915 ± 0.127	90.8 ± 6.0	0.096 ± 0.014	718.800 ± 0.771
	Uniform	7.957 ± 0.161	82.0 ± 9.6	0.096 ± 0.014	652.558 ± 1.555
	Orthogonal	8.009 ± 0.168	74.6 ± 7.3	0.099 ± 0.015	597.152 ± 1.223
Data-driven method
Variance-based	LSUV	7.916 ± 0.137	82.8 ± 7.8	0.086 ± 0.009	655.152 ± 1.072
Error-driven (original Laor)	Laor-ori	8.053 ± 0.163	77.0 ± 6.9	0.122 ± 0.011	620.208 ± 1.115
Gradient-informed	Laor	6.960 ± 0.053	89.2 ± 12.4	0.111 ± 0.014	620.899 ± 0.657
(Laor variants)	Laor-kn	7.036 ± 0.052	75.7 ± 8.1	0.120 ± 0.012	532.368 ± 0.419
	Laor-ku	7.017 ± 0.053	76.6 ± 7.6	0.149 ± 0.015	537.645 ± 0.408
	Laor-xn	8.017 ± 0.135	75.7 ± 8.1	0.119 ± 0.014	606.597 ± 1.093
	Laor-xu	8.033 ± 0.160	76.6 ± 7.6	0.123 ± 0.012	615.483 ± 1.217
	Laor-n	6.976 ± 0.064	95.7 ± 7.2	0.148 ± 0.014	667.793 ± 0.462
	Laor-u	7.948 ± 0.147	82.1 ± 6.8	0.118 ± 0.013	652.262 ± 0.996
	Laor-o	8.053 ± 0.150	76.5 ± 7.6	0.137 ± 0.013	616.200 ± 1.146

Note: Boldface highlights the top three results per metric. Lower values are preferred, as they indicate reduced computational cost. All results are averaged over 20 independent runs.

,

Table A7. Classification metrics for weight initializers on the MALSTM-FCN model. Metrics include Accuracy, Precision, Recall, F1 Score, and MCC on the test set.

Group	Weight Initializer	Test Accuracy (%)	Test Precision (%)	Test Recall (%)	Test F1 Score (%)	Test MCC (%)
Traditional	Kaiming-Normal	84.88 ± 2.26	84.74 ± 1.64	85.34 ± 6.55	84.86 ± 3.35	70.00 ± 3.89
(Data-agnostic baseline)	Kaiming-Uniform	85.08 ± 2.10	84.60 ± 1.76	86.05 ± 6.24	85.14 ± 3.11	70.39 ± 3.58
	Xavier-Normal	84.88 ± 2.26	84.74 ± 1.64	85.34 ± 6.55	84.86 ± 3.35	70.00 ± 3.89
	Xavier-Uniform	85.08 ± 2.10	84.60 ± 1.76	86.05 ± 6.24	85.14 ± 3.11	70.39 ± 3.58
	Normal	84.97 ± 1.65	87.59 ± 1.70	81.69 ± 4.94	84.43 ± 2.23	70.25 ± 2.99
	Uniform	85.36 ± 1.85	86.66 ± 1.29	83.80 ± 5.70	85.07 ± 2.59	70.95 ± 3.31
	Orthogonal	84.99 ± 1.84	84.72 ± 1.45	85.60 ± 5.55	85.02 ± 2.67	70.17 ± 3.23
Data-driven method
Variance-based	LSUV	86.19 ± 1.23	86.06 ± 1.61	86.59 ± 4.50	86.23 ± 1.73	72.54 ± 2.29
Error-driven (original Laor)	Laor-ori	85.02 ± 1.47	84.62 ± 1.73	85.82 ± 4.50	85.12 ± 1.98	70.19 ± 2.72
Gradient-informed	Laor	84.60 ± 1.52	86.60 ± 2.03	82.16 ± 5.66	84.16 ± 2.23	69.51 ± 2.72
(Laor variants)	Laor-kn	85.01 ± 1.70	84.33 ± 1.65	86.22 ± 5.06	85.15 ± 2.33	70.20 ± 3.13
	Laor-ku	84.76 ± 2.21	84.53 ± 1.70	85.38 ± 6.61	84.76 ± 3.23	69.78 ± 3.89
	Laor-xn	85.01 ± 1.70	84.33 ± 1.65	86.22 ± 5.06	85.15 ± 2.33	70.20 ± 3.13
	Laor-xu	84.76 ± 2.21	84.53 ± 1.70	85.38 ± 6.61	84.76 ± 3.23	69.78 ± 3.89
	Laor-n	84.41 ± 1.80	87.34 ± 1.42	80.69 ± 5.43	83.76 ± 2.47	69.19 ± 3.25
	Laor-u	84.43 ± 2.73	87.06 ± 1.53	81.14 ± 7.75	83.74 ± 3.88	69.31 ± 4.76
	Laor-o	85.12 ± 2.73	84.26 ± 1.51	86.63 ± 7.72	85.18 ± 4.12	70.56 ± 4.70

Note: Boldface indicates the top three scores for each metric. Higher values reflect better classification performance. Results are averaged over 20 runs for robustness.

,

Table A8. Convergence and initialization metrics for all initializers on the MALSTM-FCN model. Metrics include time per epoch, number of epochs, initialization duration, and total training time.

Group	Weight Initializer	Training Time per Epoch (s)	Number of Epochs	Weight Initial Time (s)	Total Training Time (s)
Traditional	Kaiming-Normal	7.363 ± 0.095	71.7 ± 6.5	0.104 ± 0.013	528.049 ± 0.623
(Data-agnostic baseline)	Kaiming-Uniform	7.398 ± 0.081	71.8 ± 6.8	0.097 ± 0.009	530.897 ± 0.555
	Xavier-Normal	8.318 ± 0.192	71.7 ± 6.5	0.099 ± 0.017	596.533 ± 1.258
	Xavier-Uniform	7.400 ± 0.082	71.8 ± 6.8	0.111 ± 0.011	531.044 ± 0.557
	Normal	8.377 ± 0.181	89.4 ± 7.8	0.096 ± 0.011	748.587 ± 1.408
	Uniform	8.265 ± 0.223	79.5 ± 13.7	0.095 ± 0.010	656.733 ± 3.060
	Orthogonal	8.316 ± 0.197	72.0 ± 6.2	0.126 ± 0.011	598.442 ± 1.210
Data-driven method
Variance-based	LSUV	8.271 ± 0.194	75.1 ± 9.5	0.104 ± 0.012	621.266 ± 1.838
Error-driven (original Laor)	Laor-ori	8.293 ± 0.225	72.8 ± 8.0	0.134 ± 0.010	603.850 ± 1.803
Gradient-informed	Laor	7.360 ± 0.077	89.4 ± 16.5	0.120 ± 0.016	658.065 ± 1.266
(Laor variants)	Laor-kn	7.360 ± 0.067	71.9 ± 7.6	0.121 ± 0.011	529.312 ± 0.510
	Laor-ku	7.353 ± 0.076	71.8 ± 7.7	0.119 ± 0.010	528.090 ± 0.581
	Laor-xn	8.344 ± 0.154	71.9 ± 7.6	0.149 ± 0.015	600.093 ± 1.173
	Laor-xu	8.370 ± 0.187	71.8 ± 7.7	0.117 ± 0.014	601.082 ± 1.430
	Laor-n	7.361 ± 0.074	92.0 ± 13.9	0.120 ± 0.015	677.343 ± 1.033
	Laor-u	8.300 ± 0.197	80.9 ± 14.5	0.147 ± 0.012	671.585 ± 2.866
	Laor-o	8.387 ± 0.188	70.7 ± 7.5	0.125 ± 0.007	593.112 ± 1.408

Note: Boldface highlights the top three results per metric. Lower values are preferred, as they indicate reduced computational cost. All results are averaged over 20 independent runs.

,

Table A9. Classification metrics for weight initializers on the MMAGRU-FCN model. Metrics include Accuracy, Precision, Recall, F1 Score, and MCC on the test set.

Group	Weight Initializer	Test Accuracy (%)	Test Precision (%)	Test Recall (%)	Test F1 Score (%)	Test MCC (%)
Traditional	Kaiming-Normal	85.81 ± 0.41	86.57 ± 0.63	84.84 ± 1.46	85.68 ± 0.54	71.66 ± 0.81
(Data-agnostic baseline)	Kaiming-Uniform	86.07 ± 0.46	86.46 ± 0.60	85.58 ± 1.14	86.01 ± 0.53	72.15 ± 0.90
	Xavier-Normal	85.81 ± 0.41	86.57 ± 0.63	84.84 ± 1.46	85.68 ± 0.54	71.66 ± 0.81
	Xavier-Uniform	86.07 ± 0.46	86.46 ± 0.60	85.58 ± 1.14	86.01 ± 0.53	72.15 ± 0.90
	Normal	86.19 ± 0.43	86.84 ± 0.52	85.35 ± 1.30	86.08 ± 0.54	72.39 ± 0.84
	Uniform	85.93 ± 0.53	86.82 ± 0.55	84.77 ± 1.43	85.77 ± 0.65	71.89 ± 1.03
	Orthogonal	86.44 ± 0.33	86.73 ± 0.52	86.10 ± 1.16	86.40 ± 0.43	72.89 ± 0.65
Data-driven method
Variance-based	LSUV	86.86 ± 0.35	86.93 ± 0.40	86.82 ± 1.10	86.87 ± 0.43	73.74 ± 0.69
Error-driven (original Laor)	Laor-ori	86.05 ± 0.43	86.44 ± 0.55	85.57 ± 1.23	86.00 ± 0.52	72.12 ± 0.84
Gradient-informed	Laor	86.24 ± 0.49	86.80 ± 0.59	85.53 ± 1.40	86.15 ± 0.60	72.50 ± 0.96
(Laor variants)	Laor-kn	86.04 ± 0.47	86.52 ± 0.64	85.42 ± 1.47	85.96 ± 0.59	72.09 ± 0.92
	Laor-ku	85.85 ± 0.55	86.63 ± 0.69	84.84 ± 1.82	85.71 ± 0.73	71.74 ± 1.04
	Laor-xn	86.04 ± 0.47	86.52 ± 0.64	85.42 ± 1.47	85.96 ± 0.59	72.09 ± 0.92
	Laor-xu	85.85 ± 0.55	86.63 ± 0.69	84.84 ± 1.82	85.71 ± 0.73	71.74 ± 1.04
	Laor-n	86.40 ± 0.44	87.08 ± 0.57	85.53 ± 1.19	86.29 ± 0.52	72.83 ± 0.86
	Laor-u	85.72 ± 0.65	86.92 ± 0.54	84.14 ± 1.86	85.49 ± 0.84	71.49 ± 1.23
	Laor-o	86.43 ± 0.33	86.78 ± 0.48	86.00 ± 1.08	86.38 ± 0.41	72.87 ± 0.65

Note: Boldface indicates the top three scores for each metric. Higher values reflect better classification performance. Results are averaged over 20 runs for robustness.

and

Table A10. Convergence and initialization metrics for all initializers on the MMAGRU-FCN model. Metrics include time per epoch, number of epochs, initialization duration, and total training time.

Group	Weight Initializer	Training Time per Epoch (s)	Number of Epochs	Weight Initial Time (s)	Total Training Time (s)
Traditional	Kaiming-Normal	14.691 ± 0.113	74.0 ± 6.4	0.095 ± 0.012	1087.222 ± 0.724
(Data-agnostic baseline)	Kaiming-Uniform	14.681 ± 0.147	74.4 ± 6.1	0.090 ± 0.013	1091.627 ± 0.896
	Xavier-Normal	16.319 ± 0.197	74.0 ± 6.4	0.082 ± 0.008	1207.720 ± 1.260
	Xavier-Uniform	14.695 ± 0.147	74.4 ± 6.1	0.084 ± 0.010	1092.692 ± 0.895
	Normal	16.224 ± 0.200	69.2 ± 4.5	0.127 ± 0.016	1122.856 ± 0.893
	Uniform	16.281 ± 0.203	70.7 ± 6.1	0.084 ± 0.010	1150.324 ± 1.245
	Orthogonal	16.352 ± 0.224	73.2 ± 5.3	0.079 ± 0.008	1196.220 ± 1.195
Data-driven method
Variance-based	LSUV	16.262 ± 0.210	73.9 ± 6.3	0.064 ± 0.013	1201.796 ± 1.316
Error-driven (original Laor)	Laor-ori	16.312 ± 0.221	72.4 ± 6.6	0.100 ± 0.009	1181.097 ± 1.447
Gradient-informed	Laor	14.564 ± 0.140	72.7 ± 4.9	0.102 ± 0.015	1058.180 ± 0.693
(Laor variants)	Laor-kn	14.712 ± 0.118	74.5 ± 5.6	0.127 ± 0.012	1095.417 ± 0.665
	Laor-ku	14.684 ± 0.137	72.1 ± 5.4	0.103 ± 0.012	1058.094 ± 0.742
	Laor-xn	16.359 ± 0.226	74.5 ± 5.6	0.108 ± 0.011	1218.062 ± 1.271
	Laor-xu	16.363 ± 0.214	72.1 ± 5.4	0.124 ± 0.008	1179.093 ± 1.164
	Laor-n	14.629 ± 0.146	71.1 ± 5.3	0.105 ± 0.013	1039.461 ± 0.766
	Laor-u	16.302 ± 0.231	70.1 ± 5.0	0.102 ± 0.008	1142.087 ± 1.147
	Laor-o	16.379 ± 0.235	72.6 ± 6.5	0.135 ± 0.009	1188.419 ± 1.537

Note: Boldface highlights the top three results per metric. Lower values are preferred, as they indicate reduced computational cost. All results are averaged over 20 independent runs.

.

4.1. Baseline Performance Comparison

This section presents classification and convergence results for all weight initialization strategies evaluated on the Transformer model, serving as a representative case for baseline comparison. Initializers include traditional data-agnostic methods (e.g., Xavier, Kaiming, Orthogonal), a variance-balancing strategy (LSUV), an error-driven method (Laor-ori), and eight gradient-informed variants proposed in this study. Evaluation focuses on Matthews Correlation Coefficient (MCC), which is appropriate for imbalanced classification tasks. Training time and initialization overhead are also reported.

As summarized in

Table 5. Performance and convergence comparison of weight initialization strategies on the Transformer model. Baseline methods (Xavier, Kaiming, Normal, Uniform, Orthogonal, LSUV, Laor-ori) represent established approaches from the literature, while the gradient-informed Laor variants (Laor, Laor-n, Laor-u, Laor-kn, Laor-ku, Laor-xn, Laor-xu, Laor-o) represent the novel contribution of this study.

Group	Weight Initializer	Test MCC (%)	Weight Initial Time (s)	Total Training Time (s)
Traditional	Kaiming-Normal	68.82 ± 1.09	0.101 ± 0.012	592.965 ± 0.250
(Data-agnostic baseline)	Kaiming-Uniform	68.69 ± 1.39	0.115 ± 0.012	606.364 ± 0.312
	Xavier-Normal	68.82 ± 1.09	0.097 ± 0.016	751.601 ± 0.990
	Xavier-Uniform	68.69 ± 1.39	0.098 ± 0.013	606.819 ± 0.313
	Normal	70.51 ± 1.02	0.080 ± 0.016	776.008 ± 1.158
	Uniform	68.77 ± 0.94	0.105 ± 0.013	741.499 ± 1.240
	Orthogonal	68.75 ± 1.08	0.080 ± 0.013	779.953 ± 1.305
Data-driven method
Variance- based	LSUV	70.47 ± 0.80	0.134 ± 0.014	805.164 ± 1.130
Error-driven (original Laor)	Laor-ori	68.53 ± 1.07	0.120 ± 0.005	748.190 ± 0.994
Gradient-informed	Laor	69.54 ± 1.31	0.121 ± 0.007	592.715 ± 0.624
(Laor variants)	Laor-kn	68.27 ± 1.16	0.124 ± 0.010	611.257 ± 0.218
	Laor-ku	68.15 ± 1.26	0.118 ± 0.014	602.799 ± 0.144
	Laor-xn	68.27 ± 1.16	0.120 ± 0.014	776.073 ± 1.010
	Laor-xu	68.15 ± 1.26	0.134 ± 0.012	761.259 ± 0.897
	Laor-n	70.16 ± 0.90	0.121 ± 0.016	590.652 ± 0.353
	Laor-u	68.66 ± 0.91	0.123 ± 0.013	749.999 ± 1.095
	Laor-o	68.79 ± 0.93	0.150 ± 0.014	774.926 ± 1.182

Note: Boldface highlights the top three scores for each metric across all initializers. Lower values are preferred for time-based metrics (initialization and total training time), whereas higher values reflect better classification performance (MCC). Additional metrics are reported in Appendix A (Table A1 and Table A2).

, baseline methods such as Normal and LSUV achieved high MCC scores (70.51 ± 1.02% and 70.47 ± 0.80%, respectively), but incurred the longest training times (776.0 s and 805.2 s). Laor-ori yielded similar training durations (748.2 s) but lower MCC (68.53 ± 1.07%), suggesting limited benefit from forward-loss clustering in the proxy-assisted setup.

Gradient-informed Laor variants demonstrated more favorable trade-offs. Laor reached 69.54 ± 1.31% MCC with significantly reduced training time (592.7 s), while Laor-n outperformed all methods in both MCC (70.16 ± 0.90%) and training time (590.7 s). These results suggest that backward-gradient clustering supports efficient convergence while preserving classification performance.

Figure 2 provides a visual comparison of test MCC against total training time for all initialization strategies. Highlighted markers identify the top three performers in terms of predictive accuracy and convergence efficiency.

Since this study reuses the previously validated experimental pipeline by Petchpol and Boongasame (2025) [31], standard baselines such as the Random Walk and the Random Forest are already incorporated, providing a transparent floor against which the benefits of more advanced initialization schemes can be assessed.

4.2. Generalizability of Weight Initializers Across Architectures

To evaluate the generalizability of weight initialization strategies across architectures with differing inductive biases, seventeen initializers were assessed on five deep learning models: Transformer, ConvTran, MLSTM-FCN, MALSTM-FCN, and MMAGRU-FCN. These models range from attention-only architectures to hybrids incorporating convolutional and recurrent modules. The tested initializers include traditional data-agnostic schemes (e.g., Xavier, Kaiming, Normal, Orthogonal), the variance-balancing LSUV method, the error-driven Laor-ori, and eight gradient-informed Laor variants. Detailed classification metrics, including MCC, Accuracy, Precision, Recall, and F1 Score, are provided in Appendix A Table A1, Table A3, Table A5, Table A7 and Table A9, while convergence-related statistics appear in Appendix A Table A2, Table A4, Table A6, Table A8 and Table A10. Comparative visualizations of performance and training time are shown in Figure 2, Figure 3, Figure 4, Figure 5 and Figure 6.

On the Transformer model (Figure 2), Normal and LSUV achieved the highest MCC scores (70.51 ± 1.02% and 70.47 ± 0.80%, respectively), though they incurred longer training times (>750 s). Laor-n performed comparably (70.16 ± 0.90%) while reducing total training time to 590.7 s, the fastest among all methods.

On the ConvTran architecture (Figure 3), gradient-informed variants consistently outperformed other initialization strategies. Both Laor-ku and Laor-xu achieved the highest MCC of 72.62 ± 1.95%, with Laor-ku also yielding the fastest training duration (998.282 s), closely followed by Laor-n (72.02 ± 1.78%, 998.713 s). Other gradient-informed variants, such as Laor-kn and Laor-xn, also performed competitively with MCC scores of 71.88 ± 2.23%. In contrast, traditional and variance-based initializers, including Orthogonal (71.66 ± 1.59%, 1298.746 s) and LSUV (69.85 ± 2.03%, 1299.713 s), lagged behind in both predictive accuracy and convergence efficiency.

In the MLSTM-FCN architecture (Figure 4), Normal (72.44 ± 1.94%) and LSUV (72.30 ± 2.20%) yielded the highest MCC scores. Among data-informed strategies, Laor-kn achieved 70.65 ± 2.58%, offering faster training (532.368 s) than LSUV (655.2 s), suggesting a trade-off between moderate gains in speed and slight reductions in accuracy. Notably, Kaiming-Normal also performed competitively (71.69 ± 2.04%, 520.549 s), rivaling Laor-kn in both accuracy and efficiency.

For the MALSTM-FCN architecture (Figure 5), LSUV achieved the highest MCC (72.54 ± 2.29%) but incurred longer training times (621 s). Among gradient-informed initializers, Laor-o followed with 70.56 ± 4.70%, while Laor-kn and Laor-ku offered lower training times (~528 s) with MCC scores slightly below 70%. Notably, Kaiming-Normal (70.00 ± 3.89%, ~528 s) and Kaiming-Uniform (70.39 ± 3.58%, ~531 s) performed slightly better than Laor variants in both predictive accuracy and convergence time.

On the MMAGRU-FCN model (Figure 6), which integrates attention, convolution, and gated recurrence, gradient-informed variants showed strong scalability. Laor-o (72.87 ± 0.65%) and Laor-n (72.83 ± 0.86%) closely matched the performance of LSUV (73.74 ± 0.69%) while reducing training time by more than 160 s on average (1039.5 s vs. 1201.8 s).

Across all architectures, the original Laor-ori method consistently underperformed relative to its gradient-informed counterparts, indicating that error-driven clustering based on forward loss may be less effective at capturing early-stage optimization dynamics when applied through a proxy model. In contrast, gradient-informed Laor variants demonstrated notable adaptability in deeper and hybrid models such as Transformer, ConvTran, and MMAGRU-FCN. However, in simpler recurrent architectures like MLSTM-FCN and MALSTM-FCN, traditional initializers, particularly Kaiming-Normal and Kaiming-Uniform, achieved comparable or superior results in both predictive accuracy and convergence time. These findings suggest that while gradient-informed initialization offers benefits in complex model settings, its advantage may diminish in recurrent structures where variance-preserving schemes remain effective.

4.3. Cross-Architecture Comparison and Performance-Efficiency Trade-Offs

The preceding analysis reveals architecture-specific strengths of various initialization strategies, but broader patterns also emerge when comparing their behavior across forecasting models. This section synthesizes those results, highlighting general trade-offs between classification performance and convergence efficiency across all evaluated architectures.

Figure 7 visualizes this trade-off, marking initializers that achieved top three performance in MCC, total training time, or overall efficiency. These results illustrate how initialization impacts both accuracy and runtime behavior in shallow and deep forecasting architectures.

Gradient-informed Laor variants, particularly Laor-n, Laor-o, and Laor-ku, frequently ranked among the top three initializers in both predictive accuracy and training efficiency. For instance, Laor-n achieved the highest MCC on Transformer (70.16 ± 0.90%) and remained competitive on MMAGRU-FCN (72.83 ± 0.86%) while consistently exhibiting low total training times (590.7 s and 1039.5 s, respectively). Similarly, Laor-ku and Laor-o demonstrated favorable performance across ConvTran, MALSTM-FCN, and MMAGRU-FCN, underscoring their robustness in hybrid and deep configurations.

Traditional data-agnostic initializers such as Xavier and Kaiming performed adequately in recurrent-heavy architectures, including MLSTM-FCN and MALSTM-FCN, but struggled to match the performance or efficiency of gradient-informed methods in attention-based or multi-component networks. For example, Kaiming-Normal yielded 71.69 ± 2.04% MCC on MLSTM-FCN, but fell below 69% MCC in Transformer and ConvTran, where model depth and architectural heterogeneity increased initialization sensitivity.

The LSUV method delivered high classification performance in most settings, often ranking in the top three MCC scores (e.g., 72.54 ± 2.29% on MALSTM-FCN, 73.74 ± 0.69% on MMAGRU-FCN), but incurred consistently high convergence costs. Its average total training time exceeded 750 s in all architectures, limiting its utility in computationally constrained deployments. In contrast, Laor-n and Laor-ku offered comparable or better accuracy with significantly reduced training overhead.

Laor-ori, the error-driven initializer, consistently underperformed relative to its gradient-informed successors. It exhibited middling MCC scores (e.g., 68.53 ± 1.07% on Transformer, 70.19 ± 2.72% on MALSTM-FCN) and longer training times, suggesting that forward-pass loss clustering—when implemented through a proxy model—may be insufficient for robust early-stage optimization.

Collectively, these results demonstrate that gradient-informed, proxy-assisted initialization achieves a favorable balance between accuracy and efficiency across architectures. This generalizability is particularly valuable in real-world forecasting pipelines, where frequent retraining, class imbalance, and evolving data distributions demand consistent and scalable learning behavior.

These cross-architecture results highlight the practical relevance of initialization strategies that balance predictive accuracy with convergence efficiency. In particular, deeper and hybrid models consistently benefited from optimization-aware initialization, while simpler recurrent models remained well-served by traditional schemes. These findings establish a foundation for the broader interpretation, practical implications, and limitations discussed in the next section.

4.4. Computational Overhead Analysis

This section quantifies the computational impact of different initialization strategies, contrasting weight initialization time against total training cost and forecasting accuracy.

Figure 8 presents side-by-side boxplots of initialization time, total training time, and test MCC performance. All initialization methods, including data-driven proxy-based variants, feature consistently low initialization times (~0.06–0.18 s per experiment). Standard schemes (Kaiming, Xavier, Orthogonal) fall within the same range, and even the slowest Laor variant (Laor-xn) remains only fractionally higher.

When compared to full training durations (520–1315 s), initialization overhead is always below 0.04% (e.g., 0.18 s/520 s = 0.033%). Thus, the cost of proxy-based initialization is negligible in both large-scale and constrained environments. Importantly, the middle panel shows that gradient-informed variants (Laor, Laor-n, Laor-ku, Laor-kn) also rank among the shortest overall training times rivaling or surpassing the fastest canonical schemes. The bottom panel further demonstrates that top-performing strategies in terms of MCC (up to 73.74% for LSUV) do not incur any meaningful cost penalty. For context, computing gradients directly on full models would require 7–17 s per candidate. With $N=10$ candidates, initialization would instead take 70–172 s—roughly 400–1000 times slower than the proxy method, amounting to 15–25% of total training time. By contrast, the proxy approach achieves the same gradient-informed benefit at less than 0.04% overhead, or about 3000 times more efficient.

In summary, proxy-based gradient-informed initialization delivers a compelling balance: negligible overhead, reduced total training time, and competitive or superior predictive accuracy. This efficiency advantage makes the approach particularly suitable for resource-constrained forecasting pipelines requiring frequent retraining.

5. Discussion and Conclusions

This study introduced a proxy-assisted, gradient-informed weight initialization strategy for deep time-series forecasting models. By clustering backward gradient norms from a lightweight proxy at the numerical input layer, the method provides optimization-aware yet architecture-agnostic initialization. Compared with traditional variance-preserving and error-driven strategies, it consistently improved convergence speed and predictive accuracy, particularly in deeper and hybrid architectures such as Transformer, ConvTran, and MMAGRU-FCN.

These findings highlight that initialization plays a nontrivial role in forecasting performance, especially under practical constraints of non-stationary data, class imbalance, and limited resources. Gradient-informed clustering at the input layer alone was sufficient to guide early-stage optimization, and the fixed proxy design enabled systematic evaluation across architectures with negligible overhead (less than 0.04% of total training time). The robustness of Laor-n, Laor-o, and Laor-ku across diverse models underscores the value of combining gradient-based feedback with lightweight proxy evaluation.

At the same time, limitations remain. The method showed reduced advantage in simpler recurrent architectures (e.g., MLSTM-FCN and MALSTM-FCN), where variance-based schemes such as LSUV or Kaiming initialization remained competitive. The current linear proxy and reliance on k-means clustering represent conservative design choices that trade fidelity for efficiency. More adaptive clustering algorithms or nonlinear proxy layers may better capture complex gradient landscapes. In addition, validation was confined to financial risk prediction; extending evaluation to domains such as energy demand, epidemiology, and environmental monitoring will be important for establishing broader generalizability.

Future research should also investigate sensitivity to hyperparameters such as the number of candidates and clusters. In the present study, $N=10$ was selected in accordance with the original Laor initialization methodology to ensure comparability, while $k=2$ was aligned with the binary classification structure of our forecasting task (flagged vs. not flagged stocks). Although these settings provided a solid foundation, a systematic ablation across broader ranges of $N$ and $k$ may yield practical guidance for different architectures and tasks. Another promising direction is calibration: assessing how initialization strategies affect probability reliability through Brier score, Expected Calibration Error, and reliability diagrams. Such work is particularly relevant for risk-sensitive domains like finance, where well-calibrated probabilities matter as much as raw accuracy.

In summary, the proposed gradient-informed initialization strategy offers a practical means of improving training efficiency and stability in real-world forecasting pipelines. Its negligible computational cost, architecture-agnostic design, and compatibility with established workflows make it especially suited for frequent retraining under resource constraints. While limitations remain in recurrent settings and domain coverage, the framework provides a strong foundation for future extensions toward adaptive, calibration-aware, and cross-domain initialization strategies.