GateCNN: Doppler-Temporal CNN for HAR

• GateCNN is a compact Doppler-temporal CNN accelerator that employs dual paths for Doppler embedding and temporal gating to extract discriminative micro-Doppler features for radar HAR.
• It processes continuous FMCW radar data via windowed micro-Doppler maps, capturing both Doppler-domain structure and temporal evolution with reduced computational overhead.
• GateCNN achieves comparable accuracy to recurrent baselines while enabling parallel, low-latency hardware mapping on FPGAs with minimal resource usage.

GateCNN is the compact Doppler–temporal backbone at the heart of Neural-HAR, a dimension-gated CNN accelerator designed for real-time radar human activity recognition on resource-constrained platforms. It targets edge settings in which traditional CNN–RNN pipelines are too sequential and heavy, and in which even lightweight transformer/SSM variants struggle with compute and memory budgets. Its defining operations are Doppler-vector embedding, which emphasizes how micro-Doppler content evolves over time, and dual-path gated convolutions, in which a temporal gate modulates Doppler-aware content features and is stabilized by a residual path (Wu et al., 26 Oct 2025).

1. Signal model and application setting

GateCNN is formulated for radar-based human activity recognition using continuous FMCW radar measurements. The paper evaluates it on the University of Glasgow UoG2020 continuous radar dataset, specified as 5.8 GHz, 400 MHz bandwidth, with 15 participants (14 male/1 female, 21–35 years) performing six activities—walking, sitting, standing, drinking, falling, and picking—back-to-back in 35-second sequences. Micro-Doppler signatures are derived via short-time Fourier transform into time–frequency maps, with Doppler or velocity on one axis and time on the other. The continuous stream contains 1750 time bins per 35 s, corresponding to 20 ms per time bin (Wu et al., 26 Oct 2025).

The network operates on windowed frames of shape $(C,H,W)=(1,30,28)$, where $C$ is the channel count, $H$ the number of Doppler bins, and $W$ the number of time steps in the window. In this representation, a “Doppler vector” is the $H\times1$ slice at a single time step, namely the 30-bin micro-Doppler profile at that instant. The paper does not specify the window stride.

This input construction makes the model explicitly axis-aware. One axis encodes Doppler-domain structure, and the other encodes temporal evolution. A plausible implication is that the later “dimension-gated” design is tied directly to this representation rather than being a generic gating block applied to arbitrary tensors.

2. Dimension-gated principle

The paper defines GateCNN as a parameter-efficient Doppler–temporal CNN that extracts discriminative micro-Doppler features for HAR by separating processing along Doppler and time axes and re-coupling them through temporal gating. “Dimension-gated” refers to learning a gate along the temporal dimension that selectively modulates Doppler-aware content features. The content path concentrates on Doppler-domain structure, while the gate path summarizes temporal salience (Wu et al., 26 Oct 2025).

The stated motivation is that micro-Doppler signatures exhibit salient events and periodicities over time, including gait cycles and pick/fall transitions. A temporal gate can therefore upweight informative instants and suppress less informative segments, reducing the need for deep cross-dimensional hierarchies and recurrent dependencies. The paper further states that this improves parameter/FLOP efficiency and hardware parallelism.

GateCNN’s gate is indexed per Doppler-embedding channel $d$ and time step $t$. With gate map $g(d,t)=\mathrm{ReLU}(z(d,t))$ and content features $f(d,t)=x_{conv5}(d,t)$, the fusion is

$y(d,t)=g(d,t)\cdot f(d,t)+x_{conv1}(d,t).$

The paper explicitly contrasts this with channel-wise squeeze–excitation and attention. The stated reason is computational: GateCNN uses inexpensive 1D convolutions along time and a ReLU gate, avoiding dense projections and softmax normalization.

3. Architectural formulation

GateCNN processes an input micro-Doppler map $C$0 with dual paths and a residual. The first stage is channel fusion and spatial downsampling:

$C$1

For the reported input, $C$2, $C$3, and $C$4. The paper states only that the downsampled tensor satisfies $C$5 and $C$6 and does not detail kernel sizes, strides, or paddings (Wu et al., 26 Oct 2025).

The second stage is Doppler embedding, described as a 1D convolution along Doppler and effectively a linear projection per time step:

$C$7

In component form,

$C$8

This yields a Doppler-aware feature stream across time.

The third stage is the dual-path gated convolution. A temporal path generates gates,

$C$9

and a parallel path produces content features,

$H$0

Both are reported as $H$1. Operationally, the gating is per embedding channel and per time step, with the singleton channel dimension indicating scalar gating per $H$2 that is broadcast across the content channel at that coordinate.

The fourth stage applies Doppler-domain feature extraction to the content stream through cascaded 2D convolutions:

$H$3

$H$4

$H$5

The paper does not disclose kernel sizes, strides, paddings, or normalization, and no batch/layer normalization is mentioned.

The fifth stage performs gate modulation and residual fusion:

$H$6

Here the non-negative gate $H$7 scales the Doppler-processed content features per $H$8, and the residual adds the Doppler-embedded stream $H$9 back to stabilize training and preserve gradient flow.

The classification head aggregates along the Doppler dimension and emits logits:

$W$0

$W$1

$W$2 is initialized to uniform weights to mimic averaging over Doppler, but is learned during training; the paper states that it “aggregates spatial features through a learned averaging convolution along the Doppler dimension.”

4. Training protocol and empirical performance

Training uses a person-independent split with 13 participants for training and 2 held out for testing. The evaluation is conducted across 10 random seeds, with reported seeds 0–4 in the table, to assess stability. Specific optimizer, learning-rate schedule, batch size, epochs, regularization, and augmentation are not detailed in the text. The PyTorch model is exported to ONNX for HLS conversion, and ADAMW appears in the acronyms list, but the paper does not explicitly state training hyperparameters (Wu et al., 26 Oct 2025).

GateCNN achieves 86.4% $W$3 1.71% accuracy on UoG2020 with 2,719 parameters and 0.28M FLOPs per inference, with multiply–accumulate counted as two FLOPs. The paper compares it with three recurrent baselines:

Model	Params / FLOPs	Accuracy
Bi-LSTM	3.0k / 0.034M	85.6% ± 1.42%
CNN-LSTM	3.0k / 0.041M	87.3% ± 1.33%
CNN–BiGRU	3.1k / 0.711M	88.4% ± 1.58%
GateCNN	2.7k / 0.28M	86.4% ± 1.71%

The paper characterizes GateCNN as comparable to CNN–BiGRU at a fraction of the complexity. It also notes that, although CNN-LSTM shows slightly higher accuracy with fewer FLOPs, both LSTM- and GRU-based models impose sequential dependencies across time that limit parallel hardware throughput. GateCNN is presented instead as avoiding recurrent bottlenecks and supporting parallel-friendly streaming inference.

No precision, recall, or F1 are reported, and no ablation study is provided. The qualitative rationale given in the text is that Doppler embedding, temporal gating, and the residual path all contribute to performance and stability.

5. Hardware mapping and FPGA realization

GateCNN is embedded in a dimension-gated CNN accelerator whose dual-path structure maps naturally to hardware. The temporal gate path uses 1D convolutions along time, the Doppler content path uses small 2D convolutions, and the two streams are fused by element-wise multiply and residual add. The paper describes this structure as friendly to streaming dataflow and as avoiding recurrent state (Wu et al., 26 Oct 2025).

The reported HLS toolflow is: trained PyTorch model $W$4 ONNX export $W$5 hls4ml conversion into C++ for Vitis HLS. Automated optimizations include constant folding, shape inference, and channels-last conversion. Precision is quantized to 32-bit fixed-point for FPGA synthesis.

The prototype targets a Xilinx Zynq-7000 Z-7007S at 100 MHz. All parameters are compile-time constants synthesized into LUT-based ROM, and activations and intermediate buffers are held in distributed RAM. No external memory interface is required for weights, and the design uses zero DSP and zero BRAM.

The accelerator uses a streaming architecture with dataflow pipelining. The gate and content paths execute in parallel, and element-wise modulation and residual addition are described as simple combinational operations. The paper does not enumerate initiation interval or unrolling factors, but states latency and resource usage consistent with efficient pipelining of convolutions and continuous throughput without stalls.

The reported implementation figures are 2,694 LUTs (18.71%), 2,694 FFs (9.35%), 0 DSP (0%), and 0 BRAM (0%). Total power is 0.104 W, dynamic power is 15 mW, latency is 107.5 $W$6s per inference window, and throughput is 9,302 inferences/s (9.3 kInf/s). The paper further states:

$W$7

using $W$8 mW and $W$9s. It also gives the small parameter set as approximately 11 KB, fully on-chip, thereby avoiding off-chip memory accesses.

The text links these implementation results to model scale: 0.28M FLOPs and 2.7k parameters translate to short pipelines that fit in LUT logic and distributed RAM, minimizing switching activity and power. Eliminating DSP/BRAM utilization and using fixed-point arithmetic are cited as further reductions in dynamic power, while maintaining deterministic low latency compatible with the 20 ms time-bin constraint of UoG2020. Code and HLS conversion scripts are available at https://github.com/lab-emi/AIRHAR.

6. Limitations, future directions, and terminological scope

The paper identifies several limitations. UoG2020 comprises six activities and a specific sensor setup, and broader generalization across domains—different radars, environments, and subjects—as well as robustness to domain shifts are not explored. The model operates on windowed micro-Doppler maps, and the paper notes that choices of window length, stride, and preprocessing can affect latency/accuracy trade-offs. Planned extensions include multi-radar fusion, event-driven streaming, lower-precision quantization, and on-chip learning for long-term adaptive monitoring (Wu et al., 26 Oct 2025).

The name “GateCNN” is not unique in the literature. Distinct uses in the supplied corpus include the FPGA compilation framework “CNN2Gate” (Ghaffari et al., 2020), the image-denoising “Gated Texture CNN” (Imai et al., 2020), the word-sequence model “genCNN” with a convolution-gating strategy (Wang et al., 2015), “Context-Gated Convolution” (Lin et al., 2019), convolutional networks with gated recurrent connections (Wang et al., 2021), and HCGNet’s gated dense–residual modules (Yang et al., 2019). This suggests that “GateCNN” functions less as a single canonical proper noun than as a local label for architectures that introduce learned gating into convolutional processing.

Within that broader landscape, the GateCNN of Neural-HAR is specifically a shallow Doppler–temporal CNN for radar HAR whose gate is applied along the temporal dimension while the content path remains Doppler-aware. Its distinguishing features are therefore not gating in the abstract, but dimension-specific gating, explicit Doppler embedding, and a hardware mapping designed around simple convolutions, element-wise modulation, and residual addition.