Mamba Linear Flow Encoder (MLFE)

• MLFE is a selective state-space based encoder within HyDRA, designed for closed-set RF fingerprint identification with linear time complexity vs. quadratic self-attention models.
• It processes CNN-refined RF features using a 1D convolution and SiLU gating, achieving similar accuracy to TDSE while significantly reducing training time and model size.
• MLFE derives sequence-level representations via temporal mean pooling, emphasizing distributed evidence and resource efficiency on benchmarks like SingleDay and ManyTx.

Mamba Linear Flow Encoder (MLFE) is the Mamba-based branch of HyDRA’s dual-mode encoder for radio frequency fingerprint identification (RFFI). In the HyDRA formulation, MLFE is the “Mamba-StreamEncoder” configuration: a single-layer selective state-space model (SSM) that processes convolutionally refined RF features with linear time complexity in sequence length, in contrast to the Transformer Dynamic Sequence Encoder (TDSE), which models global dependencies with quadratic complexity. Within HyDRA, MLFE functions as the high-efficiency mode for closed-set RFFI, sharing the same front-end and classifier with TDSE while replacing self-attention with Mamba-style selective state dynamics (Liu et al., 16 Jul 2025).

1. Definition, nomenclature, and scope

In HyDRA, the encoder stage is explicitly dual-mode. The architecture comprises the Convolutional Feature Refinement Extractor (CFRE), a dual-mode encoder implemented as either TDSE or MLFE, and the classifier. MLFE is therefore not a generic synonym for all Mamba encoders; in the strict sense used by HyDRA, it denotes the Mamba-based alternative to TDSE inside a shared RF fingerprinting pipeline (Liu et al., 16 Jul 2025).

Its role is defined by a computational trade-off. TDSE is described as the high-precision, attention-based mode with $O(T^2)$ dependence on sequence length $T$, whereas MLFE is the high-efficiency mode with $O(T)$ dependence on $T$. The HyDRA paper states that MLFE leverages a selective state-space model to capture long-range dependencies at linear computational complexity. This makes MLFE the resource-oriented instantiation of HyDRA for deployments in which model compactness and training speed are prioritized, while preserving near-parity with TDSE on closed-set recognition benchmarks (Liu et al., 16 Jul 2025).

The task scope reported for MLFE is narrower than the scope of HyDRA as a whole. Closed-set RFFI experiments evaluate both HyDRA(TDSE) and HyDRA(MLFE), but the reported open-set pipeline employs HyDRA(TDSE) together with softmax thresholding. A recurrent misconception is therefore that MLFE is the encoder used throughout HyDRA’s open-set results; the paper states otherwise. Another misconception is that TDSE and MLFE are fused jointly. They are not: HyDRA selects one mode at runtime, and the paper does not describe a joint fusion of TDSE and MLFE features (Liu et al., 16 Jul 2025).

2. Position within the HyDRA pipeline

HyDRA’s signal path is organized as input IQ samples, optional Variational Mode Decomposition (VMD), CFRE, dual-mode encoder, and classifier. Formally,

$$X_{\text{feat}}=\text{CFRE}(X),\qquad X_{\text{enc}}=\text{Encoder}(X_{\text{feat}}),\qquad \hat{Y}=\text{Classifier}(X_{\text{enc}}).$$

The raw input is $X \in \mathbb{R}^{b \times T \times c}$, with $c=2$ for IQ input and $c=2k$ for VMD with $k$ modes. CFRE produces $$X_{\text{feat}} \in \mathbb{R}^{b \times T \times d_m}$$, and the encoder outputs either $T$0 for TDSE or $T$1 for MLFE. The classifier then maps to $T$2 (Liu et al., 16 Jul 2025).

CFRE is the common front-end that feeds MLFE. It is a CNN-based feature extractor built from residual 1D convolutions. A ResConv1d block computes a shortcut, a temporal path with kernel $T$3 and dilation $T$4, and a larger-kernel path with $T$5, combines them by

$T$6

and stacks three such layers with increasing channels and dilation. The output is then permuted back to sequence-major form and passed to either TDSE or MLFE. In this respect, MLFE is not a standalone backbone; it is the sequence encoder that operates on CNN-refined RF features (Liu et al., 16 Jul 2025).

The representation handoff differs substantially between the two modes. TDSE prepends a CLS token and uses positional encodings, then takes the encoded CLS embedding for classification. MLFE keeps the sequence length unchanged and uses temporal mean pooling: $T$7 The shared classifier is linear,

$T$8

with $T$9 and $O(T)$0 (Liu et al., 16 Jul 2025).

3. Internal mechanics of MLFE

MLFE is implemented as a single Mamba layer. The input from CFRE is $O(T)$1, with $O(T)$2 in the reported experiments, and the encoder depth is $O(T)$3. Internally, the input is expanded by a factor $O(T)$4, processed with a 1D convolution of kernel size $O(T)$5, and selectively gated with SiLU activation before entering the selective SSM dynamics (Liu et al., 16 Jul 2025).

The core recurrence is presented in Mamba-style discrete SSM form: $O(T)$6 Here $O(T)$7 is the hidden state with $O(T)$8, $O(T)$9 is the time-step input, and $T$0 is the time-step output. The base state matrix $T$1 is learnable, while $T$2, $T$3, and the timescale parameter $T$4 are input-dependent and generated by linear projection of $T$5. The discretization is

$T$6

with $T$7 passed through softplus to ensure positivity (Liu et al., 16 Jul 2025).

This formulation matters because it distinguishes MLFE from generic recurrent networks. The HyDRA description explicitly ties MLFE to Mamba’s reinterpretation of sequence modeling as a continuous system with input-dependent discretization. The recurrence is therefore a selective SSM rather than a fixed-parameter RNN. In addition, the input stage uses 1D convolution and SiLU gating, which the paper associates with Mamba’s selective token-mixing mechanism (Liu et al., 16 Jul 2025).

The full output sequence is

$T$8

followed by mean pooling over time. This pooling choice is architecturally significant. TDSE derives a sequence-level representation from a dedicated CLS token; MLFE instead derives it from the average of time-step features. A plausible implication is that MLFE emphasizes distributed temporal evidence rather than a designated summary token, but the paper does not state a separate ablation on pooling strategy (Liu et al., 16 Jul 2025).

4. Complexity, efficiency, and empirical comparison

The principal technical motivation for MLFE is linear complexity in sequence length. In TDSE, self-attention introduces quadratic dependence on $T$9, stated in the paper as $$X_{\text{feat}}=\text{CFRE}(X),\qquad X_{\text{enc}}=\text{Encoder}(X_{\text{feat}}),\qquad \hat{Y}=\text{Classifier}(X_{\text{enc}}).$$0. In MLFE, the SSM update is a recurrence with constant-cost operations per step, yielding linear dependence on sequence length. The additional 1D convolution with $$X_{\text{feat}}=\text{CFRE}(X),\qquad X_{\text{enc}}=\text{Encoder}(X_{\text{feat}}),\qquad \hat{Y}=\text{Classifier}(X_{\text{enc}}).$$1 is also linear in $$X_{\text{feat}}=\text{CFRE}(X),\qquad X_{\text{enc}}=\text{Encoder}(X_{\text{feat}}),\qquad \hat{Y}=\text{Classifier}(X_{\text{enc}}).$$2, so the overall encoder remains $$X_{\text{feat}}=\text{CFRE}(X),\qquad X_{\text{enc}}=\text{Encoder}(X_{\text{feat}}),\qquad \hat{Y}=\text{Classifier}(X_{\text{enc}}).$$3 with respect to sequence length (Liu et al., 16 Jul 2025).

On the SingleDay dataset with lossless VMD, the reported comparison between HyDRA(TDSE) and HyDRA(MLFE) is as follows.

Metric	TDSE	MLFE
Accuracy	99.81%	99.71%
Training time on RTX 3070Ti	4929.3 s	856.0 s
Model size	600 KB	394 KB
Parameter count	146,876	96,060
FLOPs	15,746,816	15,746,816
Inference time on RTX 3070Ti	0.4219 ms	0.3962 ms
Inference time on Jetson Xavier NX	8.4073 ms	78.2622 ms

These figures support the paper’s characterization of MLFE as a compact, fast-training alternative that remains close to TDSE in accuracy. On closed-set benchmarks without preprocessing, HyDRA(MLFE) achieves 99.67% on SingleDay and 89.34% on ManyTx, compared with 99.78% and 90.22% for HyDRA(TDSE). With lossless VMD $$X_{\text{feat}}=\text{CFRE}(X),\qquad X_{\text{enc}}=\text{Encoder}(X_{\text{feat}}),\qquad \hat{Y}=\text{Classifier}(X_{\text{enc}}).$$4, the reported accuracies are 99.71% and 89.82% for HyDRA(MLFE), versus 99.81% and 90.71% for HyDRA(TDSE) (Liu et al., 16 Jul 2025).

The Jetson Xavier NX timing requires a specific caveat. The paper states that the edge-device experiment used mamba-minimal instead of the official Mamba implementation because the official library was incompatible with the installed PyTorch version, and it explicitly notes that this “does not represent the best outcome.” Accordingly, the poor MLFE Jetson timing should not be interpreted as disproving the architectural efficiency claim; the same paper presents the training-time reduction, parameter reduction, and desktop-GPU inference comparison as evidence for MLFE’s efficiency profile (Liu et al., 16 Jul 2025).

5. Task behavior, optimization, and deployment

For closed-set RFFI, MLFE shares the same supervision setup as TDSE. Training uses cross-entropy loss with class weights, described for a sample as

$$X_{\text{feat}}=\text{CFRE}(X),\qquad X_{\text{enc}}=\text{Encoder}(X_{\text{feat}}),\qquad \hat{Y}=\text{Classifier}(X_{\text{enc}}).$$5

where $$X_{\text{feat}}=\text{CFRE}(X),\qquad X_{\text{enc}}=\text{Encoder}(X_{\text{feat}}),\qquad \hat{Y}=\text{Classifier}(X_{\text{enc}}).$$6 are class weights, $$X_{\text{feat}}=\text{CFRE}(X),\qquad X_{\text{enc}}=\text{Encoder}(X_{\text{feat}}),\qquad \hat{Y}=\text{Classifier}(X_{\text{enc}}).$$7 is the one-hot target, and $$X_{\text{feat}}=\text{CFRE}(X),\qquad X_{\text{enc}}=\text{Encoder}(X_{\text{feat}}),\qquad \hat{Y}=\text{Classifier}(X_{\text{enc}}).$$8 is the softmax output from the classifier applied to $$X_{\text{feat}}=\text{CFRE}(X),\qquad X_{\text{enc}}=\text{Encoder}(X_{\text{feat}}),\qquad \hat{Y}=\text{Classifier}(X_{\text{enc}}).$$9. The paper does not describe an MLFE-specific regularizer; MLFE inherits the global training setup of HyDRA (Liu et al., 16 Jul 2025).

The reported hyperparameters are shared between TDSE and MLFE. Optimization uses Adam with initial learning rate $X \in \mathbb{R}^{b \times T \times c}$0, ReduceLROnPlateau with factor $X \in \mathbb{R}^{b \times T \times c}$1, patience 10, and minimum learning rate $X \in \mathbb{R}^{b \times T \times c}$2. The batch size is 32, the maximum number of epochs is 1000, and early stopping occurs when the learning rate reaches the minimum. Convolutional and linear layers are initialized from $X \in \mathbb{R}^{b \times T \times c}$3, while batch norm uses weight $X \in \mathbb{R}^{b \times T \times c}$4 and bias $X \in \mathbb{R}^{b \times T \times c}$5. The paper does not explicitly mention weight decay (Liu et al., 16 Jul 2025).

The task boundary between closed-set and open-set behavior is explicit. The open-set method uses temperature-scaled softmax,

$X \in \mathbb{R}^{b \times T \times c}$6

computes

$X \in \mathbb{R}^{b \times T \times c}$7

and applies the decision rule

$X \in \mathbb{R}^{b \times T \times c}$8

However, the paper specifies that this open-set algorithm employs HyDRA(TDSE), not MLFE. This is an important scope condition on the current empirical evidence for MLFE: its reported contribution is primarily the high-efficiency closed-set mode (Liu et al., 16 Jul 2025).

In deployment terms, the abstract characterizes HyDRA as achieving millisecond-level inference speed with low power consumption on NVIDIA Jetson Xavier NX. The implementation notes refine this claim by stating that the official Mamba library was replaced with mamba-minimal on the edge device for compatibility reasons, preserving input-output consistency but reducing runtime efficiency. This suggests that the practical embedded performance of MLFE is partly contingent on kernel support and software stack maturity rather than solely on model topology (Liu et al., 16 Jul 2025).

6. Related formulations and broader design patterns

Although the exact term “Mamba Linear Flow Encoder” is introduced in HyDRA, several contemporaneous papers describe closely related Mamba-based linear-time encoders in other domains. In physical field reconstruction, FR-Mamba uses stacked FNO-Mamba blocks in which a selective SSM temporal branch is fused with an FNO spatial branch through gated fusion and residual connections. Its description explicitly presents the stacked FNO-Mamba blocks as an encoder and emphasizes linear-time temporal modeling with Mamba for long sequences, while FNO handles non-local spatial structure (Long et al., 21 May 2025).

In robotic imitation learning, “Mamba as a motion encoder for robotic imitation learning” does not use the phrase MLFE explicitly, but its technical description presents Mamba as an encoder that compresses short windows of 16-dimensional joint-angle and torque data into a low-dimensional state-space representation. The paper fixes the SSM dimensionality at $X \in \mathbb{R}^{b \times T \times c}$9, uses a single Mamba block with kernel size 4, trains with MSE and AdamW at learning rate $c=2$0, and argues that the SSM structure yields smoother outputs and higher online success rates than Transformer baselines despite higher estimation errors in some settings (Tsuji, 2024).

In long-context language modeling, MaBERT defines a padding-safe interleaved Transformer-Mamba encoder. It alternates global self-attention and Mamba layers in a 12-layer MMTMMTMMTMMT schedule, introduces pre- and post-mask padding-safe masking inside Mamba blocks, and uses mask-aware attention pooling for sentence representations. When extending context from 512 to 4,096 tokens, it reports 2.36x lower training time and 2.43x lower inference latency relative to the average of encoder baselines, illustrating a hybrid pattern in which linear-time state updates are periodically re-synchronized by global attention (Kim et al., 3 Mar 2026).

In computer vision and remote sensing, 2DMCG extends the idea to a 2D selective scan. Its 2DMamba encoder performs horizontal and vertical scans over image grids, yielding $c=2$1 complexity while preserving spatial continuity that would be degraded by naive 1D flattening. The same framework adds Spatial Reorganization Fusion for bi-temporal features and a feature change flow-based decoder for multi-scale alignment, indicating that the MLFE concept can be generalized from 1D RF sequences to 2D structured inputs when the scan order and fusion operators are adapted accordingly (Kaung et al., 1 Mar 2025).

A broader generative interpretation appears in PI-Mamba, where a Mamba backbone parameterizes a time-dependent velocity field for flow matching on $c=2$2. There the encoder is not a classifier-stage sequence summarizer but a linear-time sequence model that outputs per-position velocities for Lie-group ODE integration, combined with spectral initialization from the Rouse polymer model and a differentiable constraint-enforcement operator. This suggests that the phrase “linear flow encoder” can denote either a linear-complexity Mamba encoder, as in HyDRA, or a Mamba-based encoder for explicit flow dynamics, depending on domain context (Wu et al., 17 Mar 2026).

Taken together, these works support a broader technical reading of MLFE as a design family built around four recurrent elements: selective state-space dynamics, linear scaling in sequence or grid size, lightweight local mixing through convolutions or gates, and domain-specific integration with front-ends or spatial operators. In the narrow historical sense, however, MLFE refers specifically to HyDRA’s Mamba-StreamEncoder for closed-set RF fingerprint identification (Liu et al., 16 Jul 2025).