Meta-LSTM-Affine: A Memory-Based Meta-Adaptive Affine Modeling Framework for Non-Stationary Systems

Abstract

Modeling non-stationary systems with dynamically evolving data distributions remains a fundamental challenge in modern learning and optimization problems. In this work, we adopt a generalized notion of non-stationarity, where distribution shifts across tasks and domains are treated as forms of non-stationary processes. This perspective allows us to study non-stationary behavior in controlled settings such as Few-Shot Learning (FSL) and Source-Free Domain Adaptation (SFDA), where data distributions vary across episodes or domains. Conventional normalization and feature modulation strategies often rely on batch-level statistics, leading to unstable behavior under small-batch, streaming, and distribution-shifted conditions. To address these limitations, we propose Meta-LSTM-Affine, a memory-based meta-adaptive affine modeling (normalization) framework that unifies recurrent temporal memory and meta-learning for robust feature modulation. Unlike batch-statistics-driven normalization, our method employs an LSTM-based affine parameter generator (APG) to dynamically produce channel-wise scale and shift parameters based on both current inputs and historical context. To further enhance task-level adaptability, we introduce three lightweight meta-learning mechanisms—Meta-Initialization, Meta-Conditioning, and Meta-Update—that enable rapid cross-task adaptation without modifying the backbone. A bi-level training strategy with temporal smoothness regularization ensures stable affine parameter dynamics under distributional shifts. We validate Meta-LSTM-Affine on FSL and SFDA benchmarks, including Omniglot, MiniImageNet, TieredImageNet, Office-31, MNIST, SVHN, and USPS. Experimental results show that our method consistently outperforms existing approaches such as BN, MetaBN, MetaAFN, and LSTM-Affine, achieving improved stability and adaptation performance with minimal additional computational overhead. Overall, Meta-LSTM-Affine provides a stable and efficient affine modeling mechanism for learning under generalized non-stationary conditions without relying on batch-level statistics. This generalized formulation of non-stationarity allows us to study distributional changes in controlled and widely used benchmark settings, while maintaining relevance to real-world scenarios such as streaming data, continual learning, and time-evolving environments.

1. Introduction

Affine modeling (normalization) techniques are indispensable components in modern deep neural networks, as they stabilize feature distributions and facilitate faster convergence and improved generalization. Among them, Batch Normalization (BN) [1] remains one of the most widely used methods, normalizing activations across the batch dimension and applying a learned affine transformation. Despite its popularity, BN exhibits inherent limitations when batch statistics are unreliable or unavailable, such as in small-batch training, streaming inference, and distribution-shifted scenarios. In these cases, the mismatch between training and testing statistics often leads to unstable representations and degraded performance.

In this work, we consider a generalized notion of non-stationarity, where data distributions may evolve not only over time but also across tasks or domains. From this perspective, distribution shifts encountered in Few-Shot Learning (FSL) and Source-Free Domain Adaptation (SFDA) can both be interpreted as forms of non-stationary processes, in which the underlying data distribution varies across episodes or domains. This viewpoint enables us to study non-stationary behavior in controlled and widely adopted benchmark settings, while maintaining relevance to real-world scenarios such as streaming data, continual learning, and time-evolving environments.

Several studies have attempted to address these limitations. For example, MetaBN [2] adapts BN statistics via meta-learning, while Meta-Affine Normalization (MetaAFN) [3] proposes a batch-statistics-free affine transformation framework that learns adaptive parameters without relying on batch statistics. More recently, LSTM-Affine [4] replaced fixed affine parameters with a recurrent generator, leveraging temporal memory to capture sequential patterns across inputs. However, existing batch-statistics-free designs remain complementary but incomplete: MetaAFN removes batch dependency via adaptive affine modulation, yet it does not explicitly enforce temporal consistency across sequential inputs, whereas LSTM-Affine captures temporal dynamics but struggles to generalize across tasks due to its fixed initialization and projection mechanisms—limitations that are particularly critical in Few-Shot Learning (FSL) [5,6,7,8,9,10,11] and Source-Free Domain Adaptation (SFDA) [12,13,14].

To address these complementary limitations, we propose Meta-LSTM-Affine, a unifying normalization framework that combines the batch-statistics-free design of MetaAFN, the recurrent memory of LSTM-Affine, and meta-learning for rapid task-level adaptation. Specifically, we introduce three lightweight meta-adaptation mechanisms—Meta-Initialization, Meta-Conditioning, and Meta-Update—that enhance task-specific adaptability without requiring backbone modification or incurring significant inference cost. Furthermore, we provide theoretical analysis of temporal smoothness regularization to stabilize affine parameter dynamics under non-stationary shifts.

Extensive experiments on benchmark datasets for both FSL and SFDA demonstrate that Meta-LSTM-Affine consistently outperforms BN, MetaBN, MetaAFN, and LSTM-Affine, achieving faster task-level adaptation, improved stability, and robust performance under distribution shifts. We further show that the proposed design incurs minimal inference overhead, making it suitable for deployment in settings where batch statistics are unreliable or unavailable.

Specifically, our contributions are threefold:

(1)

Unified batch-statistics-free normalization framework: We propose Meta-LSTM-Affine, which reformulates normalization as dynamic affine parameter generation and represents a unified framework that integrates recurrent temporal memory with meta-learning to address both Few-Shot Learning (FSL) and Source-Free Domain Adaptation (SFDA) under a generalized non-stationary setting.

(2)

Lightweight meta-adaptation mechanisms: We introduce three modular strategies—Meta-Initialization, Meta-Conditioning, and Meta-Update—that enable rapid task-level adaptation while keeping the backbone and recurrent generator fixed, resulting in efficient and stable adaptation.

(3)

Stability via temporal smoothness regularization: We incorporate a temporal smoothness objective to stabilize the evolution of affine parameters under non-stationary shifts, and provide empirical analysis demonstrating its effectiveness across standard FSL and SFDA benchmarks.

Compared with prior works such as MetaAFN and LSTM-Affine, the proposed framework integrates temporal modeling and task-level meta-adaptation within a unified batch-statistics-free formulation.

2. Related Work

Normalization techniques have been extensively explored for stabilizing training and improving generalization in deep neural networks. Prior research can be broadly grouped into several major directions, including traditional normalization methods and their variants, meta-learning-based adaptive normalization, batch-statistics-free approaches, and recurrent or memory-enhanced mechanisms. Below, we provide a brief overview of each category.

2.1. Batch Normalization and Its Variants

Batch Normalization (BN) [1] has been the dominant normalization method in deep neural networks, normalizing activations using batch-wise mean and variance, followed by a learnable affine transformation. While BN significantly accelerates training and improves generalization, its reliance on batch statistics makes it less reliable in small-batch training or when facing domain shifts at test time. Several variants have been proposed to mitigate this limitation. Instance Normalization (IN) [15] computes statistics per instance and channel, making it popular in style transfer tasks. Layer Normalization (LN) [16] normalizes across all channels of a layer, which is particularly effective in sequence models such as transformers. Group Normalization (GN) [17] aggregates statistics over groups of channels, offering stable performance in small-batch regimes. Despite these improvements, these methods still depend on fixed affine transformations learned during training, which may be suboptimal under distribution shifts.

2.2. Meta-Learning for Adaptive Normalization

Meta-learning has emerged as a powerful paradigm to enable rapid task-level adaptation [7,18,19]. In normalization, MetaBN [2] extends BN by adapting affine parameters through a meta-learning framework, improving performance in few-shot learning scenarios. Other works introduce feature-wise modulation mechanisms conditioned on auxiliary information [20,21], allowing scale and shift parameters to dynamically adapt to task-specific contexts. More recent approaches explore meta-modulation strategies [22] and conditional normalization [21] to incorporate task embeddings into normalization layers.

Beyond normalization, meta-learning has been extensively studied in Few-Shot Learning (FSL). Gradient-based meta-learners such as MAML [7] and metric-learning approaches, including Matching Networks [10], Prototypical Networks [5], and Relation Networks [11], demonstrate that task-conditioned adaptation enables rapid generalization from limited samples. These studies confirm the strong effectiveness of meta-learning in FSL and motivate its integration into normalization modules. Moreover, recent works extend meta-learning beyond FSL into domain adaptation [12,13], where task-specific modulation helps models generalize to unseen target domains. This naturally motivates the exploration of Source-Free Domain Adaptation (SFDA) [14], where no source data is available during adaptation.

2.3. Batch-Statistics-Free Normalization

An alternative line of research questions the necessity of batch statistics altogether. Batch-statistics-free approaches directly learn or generate affine parameters to modulate features [3,23,24]. For example, Meta Affine Transformation (MetaAFN) [3] entirely removes the whitening stage, replacing it with a lightweight meta-network that adaptively generates channel-wise scale and shift. By avoiding dependency on batch statistics, MetaAFN has shown robustness in both few-shot learning and source-free domain adaptation. Subsequent studies further explored learnable adaptive normalization [23] and sample normalization tailored for few-shot detection [24]. While Batch-statistics-free methods effectively reduce the risk of mismatched statistics, many designs rely on static affine parameters, which may be insufficient for highly dynamic or sequential settings.

2.4. Recurrent and Memory-Based Normalization

Recurrent architectures provide an alternative means of adaptation by leveraging temporal information. Long Short-Term Memory (LSTM) [25] networks can maintain hidden states across sequential inputs, making them well-suited for scenarios with gradual distribution shift. Our prior work, LSTM-Affine [4], integrates an LSTM-based generator to produce affine parameters that evolve with temporal context, resulting in more stable adaptation compared to static batch-statistics-free methods. While effective for in-episode sequential adaptation, LSTM-Affine lacks explicit task-level meta-adaptation, limiting its ability to rapidly generalize across different tasks or domains.

2.5. Toward Meta-Recurrent Normalization

Bridging batch-statistics-free design, recurrent adaptation, and meta-learning remains largely unexplored. Recent works such as MetaDiff [26] and domain generalization surveys [27] highlight the potential of combining meta-learning with advanced architectures for better generalization. However, existing meta-learning methods [18,19] do not explicitly integrate temporal memory, while recurrent generators [4,25] have yet to be combined with meta-learning mechanisms. This motivates the development of Meta-LSTM-Affine, a unified framework that incorporates batch-statistics-free efficiency [3], recurrent temporal modeling [4], and meta-learning-driven adaptability across both FSL and SFDA tasks [12,13,14].

3. The Proposed Method

We propose Meta-LSTM-Affine, a batch-statistics-free normalization framework that unifies recurrent memory and meta-learning to achieve both temporal and task-level adaptability. The key idea is to replace BN’s batch-statistics-driven normalization step with an LSTM-based affine parameter generator (APG), and further enhance its adaptability with meta-learning strategies.

3.1. Reformulating Normalization as Affine Transformation

Let $x_t\in R^{C\times H\times W}$ denote the activation map at step $t$, where $C$ is the number of channels. Standard BN [1] applies the formulae shown in Equation (1), where ${\mu }_B$ and ${\sigma }_B$ are batch statistics, and $\gamma$, $\beta \in R^C$ are learnable parameters.

$${\widehat{x}}_t={\displaystyle \frac{x_t-{\mu }_B}{{\sigma }_B}}, f_t=\gamma \odot {\widehat{x}}_t+\beta$$

(1)

MetaAFN [3] showed that the reliance on batch statistics can be removed by directly generating $\gamma$ and $\beta$ using a lightweight meta-network conditioned on input features. Similarly, LSTM-Affine [4] demonstrated that a recurrent generator can produce temporally consistent ${\gamma }_t$, ${\beta }_t$, adapting to gradual distribution shifts. In Meta-LSTM-Affine, we unify these ideas by incorporating meta-learning into the recurrent generator, enabling both temporal consistency and rapid task-level adaptation.

3.2. LSTM-Based Affine Parameter Generator

At each step $t$, we first extract a compact descriptor ${\overline{x}}_t\in R^C$ via global average pooling (GAP), as shown in Equation (2). This descriptor is fed into an LSTM [25], which maintains hidden and cell states $(h_t, c_t)$, as shown in Equation (3), where $\mathsf{\Theta }$ are LSTM parameters. The hidden state $h_t\in R^d$ is then projected into affine parameters, where $W_p\in R^{2C\times d}$ and $b_p\in R^{2C}$, as shown in Equation (4). The final affined output $f_t$ is obtained as shown in Equation (5). Thus, ${\gamma }_t$, ${\beta }_t$ evolve with temporal dynamics while remaining independent of batch statistics. We deliberately keep the LSTM parameters $\mathsf{\Theta }$ fixed during meta-adaptation, as updating recurrent parameters under few-shot or streaming settings may lead to unstable temporal dynamics and overfitting. Therefore, we restrict adaptation to the lightweight projection head, which enables efficient task-specific refinement while preserving the temporal structure learned by the LSTM. Although the input samples are not strictly sequential, the LSTM serves as a mechanism to model gradual distributional adaptation across samples within an episode.

The overall workflow of the LSTM-based affine parameter generator is illustrated in Figure 1 [4], highlighting its role as a batch-statistics-free alternative to BN.

$${\overline{x}}_t=GAP\left(x_t\right)$$

(2)

$$\left(h_t, c_t\right)=LSTM({\overline{x}}_t,h_{t-1}, c_{t-1};\mathsf{\Theta })$$

(3)

$$[{\gamma }_t,{\beta }_t]=W_p·h_t+b_p$$

(4)

$$f_t={\gamma }_t\odot x_t+{\beta }_t$$

(5)

3.3. Meta-Learning Integration

While the LSTM-based affine parameter generator (APG) provides temporal adaptation, its projection parameters $W_p$, $b_p$ and recurrent weights $\mathsf{\Theta }$ remain static after training, limiting task-level generalization under distribution shifts (e.g., FSL or SFDA). This limitation is particularly problematic in Few-Shot Learning (FSL), where each new task has its own distribution and requires rapid adaptation. To address this, we introduce three meta-learning mechanisms that incorporate the support set $S$ into the adaptation process.

(a)

Meta-Initialization

Instead of starting the LSTM with fixed hidden and cell states, we generate task-specific initial states from the support set, as shown in Equation (6), where $f_{\phi }\left(·\right)$ is a learnable meta-network trained end-to-end during meta-training to produce task-adaptive initializations. This design ensures that each task begins from an initialization aligned with its underlying distribution. The loss on the support set $L_S$ and the loss on the query set $L_Q$ share the same formulation, as shown in Equation (7). Each loss consists of: Equation (1) a standard task classification loss $l_t$ computed from the classifier output, and Equation (2) a temporal smoothness penalty $r_t$, weighted by $\lambda$, that encourages the affine parameters $({\gamma }_t,{\beta }_t)$ to evolve smoothly across timesteps, as defined in Equation (8). Intuitively, this regularization discourages abrupt changes in the generated affine parameters between consecutive timesteps, stabilizing feature modulation under non-stationary input streams and complementing the temporal modeling provided by the LSTM. Meta-Initialization primarily addresses task-level distribution mismatch at the sequence onset, without altering the temporal dynamics governed by the LSTM.

$$\left(h_0, c_0\right)=f_{\phi }\left(S\right)$$

(6)

$$L_R={\sum }_{t=0}^T(l_t+\lambda r_t), R\in \{S, Q\}$$

(7)

$$\mathrm{S}\mathrm{m}\mathrm{o}\mathrm{o}\mathrm{t}\mathrm{h}({\gamma }_t,{\beta }_t;{\gamma }_{t-1},{\beta }_{t-1})=\left\{\begin{array}{c}\parallel {\gamma }_t-{\gamma }_{t-1}{\parallel }_2^2+\parallel {\beta }_t-{\beta }_{t-1}{\parallel }_2^2\mathrm{f}\mathrm{o}\mathrm{r} t>1\\ 0 \mathrm{e}\mathrm{l}\mathrm{s}\mathrm{e}\end{array}\right.$$

(8)

(b)

Meta-Conditioning

A task embedding is extracted from the support set, $z_S=g_{\psi }\left(S\right)$, for example via class prototypes or attention-based pooling, where $g_{\psi }(·)$ is a learnable meta-network. The affine parameters are then generated as shown in Equation (9), where $h_t$ captures temporal patterns, while the additional term $U{z}_S$ injects task-specific information. While Meta-Conditioning injects task context as a static conditioning signal, it does not involve parameter updates and therefore complements, rather than overlaps with gradient-based refinement. Thus, affine parameters depend both on temporal memory and the task embedding, enabling per-task adaptation without modifying the backbone. Importantly, $U$ is learned during meta-training but kept fixed during meta-test inference, while adaptation arises solely from the task-dependent $z_S$.

$$[{\gamma }_t,{\beta }_t]=W_p{h}_t+U{z}_S+b_p$$

(9)

(c)

Meta-Update

A lightweight inner-loop adaptation is applied only to the projection head $(W_p,b_p)$, while keeping the backbone and LSTM fixed. Given the support set loss $L_S$, one or a few gradient steps yield updated parameters $({W^{\prime }}_p,{b^{\prime }}_p)$, as shown in Equation (10), where $\alpha$ is optimized during meta-training and remains fixed at inference, rather than being treated as a hyperparameter or generated by a meta-network. This design allows rapid refinement of the affine projection head using only the support set, while avoiding adaptation of the entire backbone or LSTM generator. This localized adaptation strategy follows recent observations in meta-learning that fast task-level adaptation is most effective when confined to task-specific affine or projection layers, rather than deep feature extractors.

$${W^{\prime }}_p=W_p-\alpha {\nabla }_W{L}_S, {b^{\prime }}_p=b_p-\alpha {\nabla }_b{L}_S$$

(10)

It is important to clarify that the meta-networks introduced in our design are not responsible for training or generating the parameters of the LSTM itself. Instead, they act as auxiliary modules that enhance task adaptability at different stages of the adaptation process. Meta-Initialization provides task-specific initial hidden and cell states, Meta-Conditioning injects task-level information into the affine generation process, and Meta-Update refines the affine projection parameters through lightweight gradient-based adaptation. Together, these mechanisms align initialization, conditioning, and refinement, enabling efficient task-level adaptation under diverse distribution shifts.

The overall episodic meta-training procedure integrates three meta-learning mechanisms, as illustrated in Figure 2. Meta-Initialization performs a one-shot mapping $(h_0,c_0)=f_{\phi }\left(S\right)$ to generate task-specific initial states from the support set. Meta-Conditioning injects the task embedding $z_S$ into the affine projection process, enabling task-aware modulation of the generated affine parameters. Meta-Update applies a lightweight inner-loop refinement to the projection head parameters based on the support set loss, allowing rapid task-level adaptation without modifying the backbone or the recurrent generator.

The overall episodic meta-training procedure is summarized in Algorithm 1, while the conceptual roles of the three meta-learning mechanisms are illustrated in Figure 2. Meta-Initialization performs one-shot mapping $\left(h_0,c_0)=f_{\varphi }(S\right)$ at the beginning of each episode to align the temporal dynamics with the task distribution. Meta-Conditioning incorporates the task embedding $z_S$ into the affine projection process, enabling task-aware modulation of the generated parameters. Meta-Update applies a lightweight inner-loop refinement to the affine projection head parameters based on the support set loss, as implemented in Algorithm 1.

In addition, temporal smoothness regularization is applied to stabilize the evolution of affine parameters across steps, as described in Algorithm 2, while the inference procedure is summarized in Algorithm 3.

All three mechanisms are modular and can be independently activated depending on the target scenario (e.g., FSL or SFDA), without requiring any modification to the backbone network or the underlying LSTM architecture.

Algorithm 1. Episodic Meta-Training for Meta-LSTM-Affine

Input: Task distribution $p\left(T\right)$; backbone parameters $\theta$; LSTM parameters $\mathsf{\Theta }$; projection head $W_p, b_p$; optional Meta-Init network $f_{\phi }$, Meta-Conditioning network $g_{\psi }$, and conditional matrix $U$; inner step size $\alpha$; smoothness weight $\lambda$

Output: Trained parameters $\theta$, $\mathsf{\Theta }$, $W_p$, $b_p$, $\phi$, $\psi$, $U$, $\alpha$

1.  repeat # for each episode

2.    Sample a task $T~p\left(T\right)$ with support set $S$ and query set $Q$;

3.    if the Meta-Initialization module is used then

4.     $\left(h_0, c_0\right)\leftarrow f_{\phi }\left(S\right)$

5.    else

6.     $\left(h_0, c_0\right)$ ← $\left(0, 0\right)$;

7.    if the Meta-Conditioning module is used then

8.     $z_S\leftarrow g_{\psi }\left(S\right)$

9.    else

10.    $z_S\leftarrow \mathbf{0}$;

11.   # Initialize inner projection parameters:

12.   ${W^{\prime }}_p\leftarrow W_p; {b^{\prime }}_p\leftarrow b_p$;

13.   # Support set forward (inner loop):

14.   Initialize $L_S\leftarrow 0$; $\left(h, c\right)\leftarrow \left(h_0, c_0\right)$ and clear $\left({\gamma }_{prev}, {\beta }_{prev}\right)$;

15.   for each $\left(x_t, y_t\right)\in S$ do

16.     # Compute descriptor

17.     ${\overline{x}}_t\leftarrow GAP\left(x_t\right)$; $\left(h, c\right)\leftarrow LSTM(\overline{x},h, c;\mathsf{\Theta })$;

18.     # Generate affine parameters

19.     [${\gamma }_t,{\beta }_t]\leftarrow W_{p}h+U{z}_S+b_p$;

20.     $f_t\leftarrow {\gamma }_t\odot x_t+{\beta }_t$

21.     compute task loss $l_t$ and smoothness penalty $r_t$; # using Algorithm 2

22.     $L_S\leftarrow L_S+l_t+\lambda r_t$; # update loss

23.     $({\gamma }_{prev}, {\beta }_{prev})\leftarrow ({\gamma }_t,{\beta }_t)$;

24.   end for

25.   # Meta-Update (if enabled):

26.   ${W^{\prime }}_p\leftarrow {W^{\prime }}_p-\alpha {\nabla }_{{W^{\prime }}_p}{L}_S$;

27.   ${b^{\prime }}_p\leftarrow {b^{\prime }}_p-\alpha {\nabla }_{{b^{\prime }}_p}{L}_S$;

28.   # Query set forward (outer loop):

29.   $L_Q\leftarrow 0$; $\left(h, c\right)\leftarrow \left(h_0, c_0\right)$;

30.   for each $\left(x_t, y_t\right)\in Q$ do

31.     ${\overline{x}}_t\leftarrow GAP\left(x_t\right)$; $\left(h, c\right)\leftarrow LSTM(\overline{x},h, c;\mathsf{\Theta })$;

32.     # Generate affine parameters

33.     [${\gamma }_t,{\beta }_t]\leftarrow {W^{\prime }}_{p}h+U{z}_S+{b^{\prime }}_p$;

34.     $f_t\leftarrow {\gamma }_t\odot {\widehat{x}}_t+{\beta }_t$;

35.     Compute task loss $l_t$ and smoothness penalty $r_t$; # using Algorithm 2

36.     $L_Q\leftarrow L_Q+l_t+\lambda r_t$; # update loss

37.     $({\gamma }_{prev}, {\beta }_{prev})\leftarrow ({\gamma }_t,{\beta }_t)$

38.   end for

39.   $L_{meta}\leftarrow L_Q+\lambda \sum r_t$; # Compute outer objective

40.   # Outer update:

41.   Apply gradient descent to $\theta$, $\mathsf{\Theta }$, $W_p, b_p, \varphi$, $\psi$, $U$ (and $\alpha$ if learnable)

42. until convergence or maximum episodes reached

Algorithm 2. Temporal Smoothness Regularization

1. for $t>1$:

2.   $r_t\leftarrow \mathrm{S}\mathrm{m}\mathrm{o}\mathrm{o}\mathrm{t}\mathrm{h}({\gamma }_t, {\beta }_t; {\gamma }_{t-1}, {\beta }_{t-1})$;

3. for $t=1$:

4.   set the penalty to 0.

Algorithm 3. Meta-Test (Inference)

Input: Trained $\theta$, $\mathsf{\Theta }$, $W_p$, $b_p$, $\phi$, $\psi$, $U$, $\alpha$; new task with support $S$ and query $Q$.

5. Meta-Init: If enabled, compute $\left(h_0, c_0\right)\leftarrow f_{\phi }\left(S\right)$; else $\left(h_0, c_0\right)\leftarrow \mathbf{0}$;

6. Meta-Conditioning: If enabled, compute task embedding $z_S\leftarrow g_{\psi }\left(S\right)$; otherwise set $z_S\leftarrow \mathbf{0}$;

7. Meta-Update (optional): Apply one light inner-step update to $W_p, b_p$ with $S$;

8. Query inference: Reset states to $\left(h_0, c_0\right)$, then generate $\left({\gamma }_t,{\beta }_t\right)$ and final predictions.

3.4. Bi-Level Training Objective

Meta-training follows an episodic paradigm [7,18]. For each episode, the support set $S$ is used to perform task adaptation (Meta-Initialization, Meta-Conditioning, or Meta-Update), while the query set $Q$ evaluates performance. The outer-loop meta-objective minimizes the loss, $L_{\mathrm{m}\mathrm{e}\mathrm{t}\mathrm{a}}$, as given in (11). Here, $L_Q\left({\gamma }_t,{\beta }_t\right)$ denotes the standard task classification loss computed on the query set $Q$ using the normalized features produced by the affine parameters $\left({\gamma }_t,{\beta }_t\right)$. The term $R_{\mathrm{s}\mathrm{m}\mathrm{o}\mathrm{o}\mathrm{t}\mathrm{h}}$, as defined in (12), is the temporal smoothness regularization that encourages the affine parameters to vary smoothly across timesteps, and $\lambda$ is a regularization weight. A single-level objective was insufficient to simultaneously enforce temporal smoothness and task-level adaptation, motivating the use of a bi-level formulation.

During meta-training, tasks are constructed episodically with disjoint support and query sets. Class splits for training, validation, and testing strictly follow standard Few-Shot Learning protocols to ensure fair evaluation and prevent data leakage across tasks.

$$L_{\mathrm{m}\mathrm{e}\mathrm{t}\mathrm{a}}={\mathrm{E}}_{{\rm T}}[L_Q+\lambda R_{\mathrm{s}\mathrm{m}\mathrm{o}\mathrm{o}\mathrm{t}\mathrm{h}}({\gamma }_{1:T}, {\beta }_{1:T}\left)\right]$$

(11)

$$R_{\mathrm{s}\mathrm{m}\mathrm{o}\mathrm{o}\mathrm{t}\mathrm{h}}({\gamma }_{1:T}, {\beta }_{1:T})={\sum }_{t=0}^T{r}_t$$

(12)

3.5. Properties and Advantages

The overall architecture of Meta-LSTM-Affine is illustrated in Figure 3, where a shared encoder processes both the adaptation data and the inference data. The data used for task-level adaptation (referred to as support data in the meta-learning sense) is passed through the same encoder and GAP operation to form adaptation features, which are utilized by the Meta-Initialization, Meta-Conditioning, and Meta-Update modules. These meta-modules provide task-level conditioning signals that configure the LSTM-based affine generator. In contrast, the inference (query) samples follow the main inference pathway, where their features are modulated by the LSTM-APG to produce temporally evolving affine parameters $({\gamma }_t, {\beta }_t)$.

The proposed Meta-LSTM-Affine framework offers the following advantages: (1) Batch-statistics-free efficiency: It avoids the need for batch statistics, maintaining stability under small-batch or distribution-shifted conditions [3,23,24]. (2) Temporal adaptation: The LSTM-based affine generator captures sequential dependencies, enabling smooth and context-aware evolution of the affine parameters [4,25]. (3) Task-aware generalization: Through Meta-Initialization, Meta-Conditioning, and Meta-Update, the model supports fast task-level adaptation to new domains or tasks, without requiring retraining of the backbone network [2,7,18,19,21,22]. (4) Lightweight design: Only compact projection heads and meta-modules are introduced, preserving backbone compatibility and ensuring efficient inference.

4. Experimental Results

We evaluate Meta-LSTM-Affine on both Few-Shot Learning (FSL) and Source-Free Domain Adaptation (SFDA) benchmarks to assess its effectiveness and compare it against existing normalization methods. We focus on representative normalization-based methods to enable controlled and fair comparison under consistent architectures and training protocols, isolating the effect of the proposed normalization design.

4.1. Datasets

For FSL, we adopt three widely used benchmarks: Omniglot [6], MiniImageNet [8], and TieredImageNet [28]. Omniglot contains 1623 handwritten character classes from 50 alphabets, each with 20 samples; we follow the standard split of 1200 classes for training, 100 for validation, and 323 for testing. MiniImageNet consists of 100 classes sampled from ImageNet, each with 600 images, divided into 64 training, 16 validation, and 20 testing classes. TieredImageNet is a larger subset of ImageNet with 608 classes grouped into 34 higher-level categories; the standard split assigns 351 classes for training, 97 for validation, and 160 for testing. These benchmarks provide a comprehensive evaluation of few-shot classification under varying levels of complexity.

For SFDA, we consider both digit recognition and object recognition tasks. For digits, we use MNIST [12], USPS [13], and SVHN [14], evaluating domain adaptation across U→M, S→M, and M→U. MNIST includes 70,000 grayscale digit images (28 × 28, 10 classes), USPS contains 9298 grayscale digit images (16 × 16, 10 classes), and SVHN provides 99,289 color digit images (32 × 32, 10 classes) collected from natural scenes. For objects, we use the Office-31 dataset [7], which consists of 4652 images in 31 categories from three domains: Amazon (A), Webcam (W), and DSLR (D). We evaluate all six transfer tasks (A→D, A→W, W→D, W→A, D→A, D→W). These datasets collectively test adaptability under both low-level digit recognition and high-level object classification with significant domain shifts.

4.2. Experimental Setup

For FSL experiments, we follow the standard episodic training paradigm [5,7,8,9], where each episode consists of a support set for task adaptation and a query set for evaluation. Experiments are conducted under the 5-way 5-shot classification settings, following our previous work [4] to ensure consistency in comparison. For the backbone, we use a 4-layer CNN with 64 filters per layer on Omniglot, and ResNet-12 on MiniImageNet and TieredImageNet. Models are optimized using Adam with an initial learning rate of 0.001, which is decayed by half every 20,000 episodes. Meta-training is performed over 100,000 episodes, with meta-validation every 1000 episodes.

For evaluation, we report the average accuracy of over 600 randomly sampled episodes. In addition, all results are reported as the mean over 5 independent runs with different random seeds, along with standard deviations and 95% confidence intervals. The confidence intervals are computed across independent runs.

For SFDA, we follow the SHOT framework [10], where the classifier is frozen, and only the feature extractor (with BN replaced by Meta-LSTM-Affine) is adapted using unlabeled target data. Training objectives combine information maximization loss with entropy minimization and pseudo-label cross-entropy loss. We train for 30 epochs with a mini-batch size of 64, an initial learning rate of 0.01, and cosine decay down to 0.001. For Office-31, we use ResNet-50 [5] as the backbone under the same protocol, evaluating all six domain adaptation tasks.

Although the overall framework may involve test-time optimization of the feature extractor under the SHOT protocol, the proposed Meta-LSTM-Affine module itself does not require explicit backpropagation-based updates during inference. Instead, it performs feed-forward adaptation via dynamic affine parameter generation. In contrast, the overall SFDA framework may still involve standard optimization procedures (e.g., SHOT).

4.3. Results on Few-Shot Classification

Table 1. Few-shot classification accuracy (%) with 95% confidence intervals on Omniglot, MiniImageNet, and TieredImageNet under the 5-way 5-shot settings.

Method	Omniglot	MiniImageNet	TieredImageNet	Avg.
BN	94.8	67.5	72.4	79.4
MetaBN	95.2	70.2	75.5	80.3
MetaAFN	96.7	72.3	77.0	82.0
LSTM-Affine	99.0	74.5	79.4	84.3
Meta-LSTM-Affine	99.7	75.2	80.1	85.0

reports the classification accuracies on Omniglot, MiniImageNet, and TieredImageNet under the 5-way 5-shot settings. Meta-LSTM-Affine achieves the best performance across all datasets and evaluation protocols, consistently outperforming BN, MetaBN, MetaAFN, and LSTM-Affine. The gains are most significant on MiniImageNet, which is considered a challenging benchmark due to its fine-grained categories and large intra-class variability. These results highlight that combining temporal memory with meta-learning in a batch-statistics-free design enables both rapid task-level adaptation and stable performance, avoiding the instability often observed in BN under small or imbalanced batches. Notably, the performance gap between LSTM-Affine and Meta-LSTM-Affine is more pronounced on MiniImageNet and TieredImageNet than on Omniglot. This observation suggests that temporal adaptation alone is insufficient when inter-task distribution shifts are substantial, and that explicit task-level conditioning and initialization are necessary to handle higher visual complexity and semantic diversity.

Table 2. Source-Free Domain Adaptation (SFDA) accuracy (%) on digit classification datasets (MNIST, USPS, SVHN). Reported results are averaged over multiple runs across U→M, S→M, and M→U transfer tasks.

Method	U→M	S→M	M→U	Avg.
BN	97.71	99.05	98.17	98.31
MetaBN	97.66	98.82	98.17	98.22
MetaAFN	97.61	99.09	98.17	98.29
LSTM-Affine	98.04	99.10	98.66	98.60
Meta-LSTM-Affine	98.32	99.37	98.92	98.87

summarizes the average accuracies on the digit classification tasks (U→M, S→M, M→U). Meta-LSTM-Affine achieves the best overall performance, surpassing all competing normalization methods. Unlike optimization-based SFDA methods that rely on backpropagation at test time, our framework leverages the proposed module to provide efficient adaptation without requiring extensive test-time optimization. This design yields both improved accuracy and inference efficiency, indicating that recurrent affine generation can serve as an effective alternative to optimization-based test-time adaptation under source-free constraints.

Table 3. Source-Free Domain Adaptation (SFDA) accuracy (%) on Office-31 dataset under all transfer directions (Amazon → Webcam, Amazon → DSLR, Webcam → DSLR, Webcam → Amazon, DSLR → Amazon, DSLR → Webcam).

Method	A→W	A→D	W→D	W→A	D→A	D→W	Avg.
BN	92.24	90.29	99.90	72.82	73.39	97.78	87.74
MetaBN	92.20	92.21	99.80	71.14	73.77	98.03	87.86
MetaAFN	90.25	93.52	99.60	76.75	75.21	98.10	88.91
LSTM-Affine	92.26	94.05	99.90	77.94	76.14	98.37	89.78
Meta-LSTM-Affine	92.66	94.45	99.98	78.34	76.54	98.77	90.12

presents the results on the Office-31 benchmark under six domain transfer settings. Meta-LSTM-Affine achieves the highest average accuracy, with especially significant improvements on the challenging A→W and W→A transfers, which involve substantial visual domain gaps. The results confirm that the integration of recurrent temporal modeling and meta-level adaptation provides a robust mechanism for aligning features in the absence of source data. In particular, the consistent gains on A→W and W→A transfers indicate that Meta-LSTM-Affine effectively handles asymmetric domain shifts, where source and target domains differ substantially in both visual statistics and data acquisition conditions. Furthermore, the lightweight nature of our method ensures that these improvements are obtained without incurring additional computational overhead compared to BN-based baselines.

In summary, Meta-LSTM-Affine consistently outperforms prior approaches in both FSL and SFDA benchmarks. The improvements validate the effectiveness of unifying batch-statistics-free design, recurrent memory, and meta-learning, enabling stable and adaptable normalization across diverse distributional settings.

4.4. Ablation Studies

To analyze the contribution of each component, we evaluate three variants:

w/o Meta-Initialization: Removing task-specific initialization of LSTM states.

w/o Meta-Conditioning: Disabling task embedding conditioning.

w/o Meta-Update: Removing inner-loop adaptation of projection head.

For FSL, the results in

Table 4. Average classification accuracy (%) for the ablation study of Meta-LSTM-Affine in the 5-shot setting. The “Gap to Full” column quantifies the performance drop relative to the full model.

Method	Avg (Few-Shot)	Gap to Full
Meta-LSTM-Affine	85.0	—
w/o Meta-Init	83.1	−1.9
w/o Meta-Cond.	83.5	−1.5
w/o Meta-Update	82.0	−3.0

show that each mechanism contributes positively in the 5-shot setting. Meta-Update notably improves stability across episodes, while Meta-Conditioning enhances the model’s adaptation capability. Removing Meta-Initialization results in slower convergence and reduced consistency during task adaptation. The “Gap to Full” values in Table 4 further quantify the performance degradation caused by disabling each component.

For SFDA, the results in

Table 5. Average accuracy (%) of different model variants on SFDA tasks over the digit and Office-31 datasets. The “Gap to Full” columns indicate accuracy degradation compared to the full Meta-LSTM-Affine model.

Method	Avg (Digits)	Avg (Office-31)	Gap to Full (Digits)	Gap to Full (Office-31)
Meta-LSTM-Affine	98.87	90.12	0.00	—
w/o Meta-Init	98.22	89.30	−0.65	−0.82
w/o Meta-Cond.	98.34	89.42	−0.53	−0.70
w/o Meta-Update	98.34	88.93	−0.53	−1.19

demonstrate that temporal adaptation alone (LSTM-Affine) is insufficient for robust cross-domain transfer. Meta-Conditioning significantly improves adaptation to unseen domains by leveraging task embeddings, while Meta-Update enhances stability when adaptation requires fine-grained adjustment of affine parameters. Together, the three mechanisms achieve the best accuracy across both digit recognition and Office-31 transfer tasks. The gaps listed in Table 5 highlight the individual contributions of each meta-learning mechanism to the overall transfer performance. Overall, the ablation results confirm that the three meta-learning mechanisms play complementary roles: Meta-Initialization aligns the adaptation starting point, Meta-Conditioning injects task context, and Meta-Update refines task-specific affine projections. Removing any single component leads to measurable performance degradation, validating the necessity of the proposed unified design.

4.5. Computational Complexity Analysis

To further evaluate the efficiency of the proposed method, we analyze its computational complexity in terms of parameter count and floating-point operations (FLOPs), and compare it with representative normalization approaches, including BN, MetaAFN, and LSTM-Affine. The reported FLOPs are estimated under the same backbone setting for fair comparison.

As shown in

Table 6. Complexity comparison.

Method	Params (Relative)	FLOPs (Relative)	Overhead
BN	1.00×	1.00×	–
MetaAFN	1.02×	1.01×	+2%
LSTM-Affine	1.05×	1.03×	+5%
Meta-LSTM-Affine	1.07×	1.04×	+7%

, Meta-LSTM-Affine introduces only a modest increase in both parameters and computational cost compared to the baseline methods. Since the backbone network remains unchanged, the additional overhead mainly comes from the affine parameter generator and the lightweight meta-adaptation modules. Notably, the LSTM-based generator operates on compact feature descriptors obtained via global average pooling, rather than full feature maps, which significantly limits the computational burden.

Compared with LSTM-Affine, the additional cost of Meta-LSTM-Affine mainly arises from the meta-learning components (Meta-Initialization, Meta-Conditioning, and Meta-Update), which are lightweight and only applied during adaptation. As a result, the overall increase in FLOPs remains modest, as quantified in Table 6.

These results demonstrate that the proposed framework achieves improved adaptability under non-stationary conditions while maintaining relatively low computational overhead compared to baseline methods.

5. Conclusions

In this paper, we introduced Meta-LSTM-Affine, a batch-statistics-free affine modeling (normalization) framework that unifies recurrent temporal memory with meta-learning to achieve both temporal and task-level adaptability. Unlike Batch Normalization, which relies on potentially unstable batch-level statistics, Meta-LSTM-Affine reformulates normalization as dynamic affine parameter generation, enabling robust feature modulation without dependence on batch statistics.

Experimental results from Few-Shot Learning (FSL) benchmarks (Omniglot, MiniImageNet, and TieredImageNet) and Source-Free Domain Adaptation (SFDA) tasks (MNIST, USPS, SVHN, Office-31) demonstrate the effectiveness of the proposed design under two representative yet challenging settings. In FSL, Meta-LSTM-Affine improves stability and generalization under limited data, while in SFDA, it mitigates performance degradation caused by domain shift without access to source data. These results suggest that coupling recurrent memory with task-aware modulation provides a principled mechanism for handling both intra-task sequential dynamics and inter-task distributional variation.

The proposed framework is particularly suitable for learning under generalized non-stationary conditions, where data distributions evolve across tasks, domains, or time. In this work, we validate this capability using controlled benchmark settings (FSL and SFDA), which capture representative forms of distributional variation.

Beyond these case studies, the proposed framework highlights a broader perspective on affine modeling: rather than relying on fixed statistics or static affine parameters, normalization can be viewed as a dynamic, context-dependent transformation driven by both temporal history and task information.

Several directions merit further investigation. Future work includes extending the framework to real-world streaming and time-evolving scenarios, exploring more advanced meta-optimization strategies, and incorporating attention-based or transformer-style memory to better capture long-range dependencies.