GazeLNN: Lightweight Gaze & Attention Inference

• GazeLNN is a lightweight, gaze- and attention-centered neural framework designed for efficient real-time inference in AR/VR and autonomous navigation systems.
• It leverages memory-centric LUT-based gaze estimation and ROI-driven object detection to reduce computation, energy consumption, and latency.
• An alternate design employs an auto-regressive scanpath predictor using MobileNetV3 with CfC modules, achieving high-speed performance on low-power devices.

GazeLNN designates lightweight gaze- and attention-centered neural architectures introduced in 2026 for two distinct problem settings. In "GLANCE: Gaze-Led Attention Network for Compressed Edge-inference" (Solanki et al., 16 Mar 2026), it denotes a two-stage pipeline for AR/VR object detection that combines differentiable weightless neural networks for gaze estimation with attention-guided region-of-interest object detection. In "Fast Human Attention Prediction for Fixation-guided Active Perception in Autonomous Navigation" (Mohammed et al., 18 Jun 2026), it denotes an auto-regressive scanpath prediction model that uses MobileNetV3 for feature extraction and a Liquid Neural Network recurrent engine to predict sequential fixation heatmaps. The shared premise across these usages is explicit attention modeling under tight latency, power, and on-board compute constraints.

1. Terminological scope and problem domains

Within GLANCE, GazeLNN is a gaze-led attention mechanism for compressed edge inference in AR/VR systems. The stated target is real-time object detection under sub-10\,ms latency and tight power budgets, with gaze estimation used to guide selective detection on attended regions rather than uniform full-frame processing (Solanki et al., 16 Mar 2026).

In autonomous navigation, GazeLNN is a scanpath prediction model for fixation-guided active perception. It predicts human-like fixation sequences from a current image and fixation history, then feeds those predictions into a reinforcement-learning control policy that adjusts robot motion and camera orientation so as to center predicted human fixations (Mohammed et al., 18 Jun 2026).

A recurrent source of ambiguity is therefore nomenclature rather than method. The same label refers, in one case, to a memory-centric gaze-estimation-plus-ROI-detection pipeline, and in the other, to a MobileNetV3-plus-CfC recurrent scanpath predictor. This suggests a broader emphasis on efficient attention-centric inference rather than a single canonical architecture.

2. Weightless gaze estimation in GLANCE

The GLANCE formulation begins from a normalized grayscale eye image $x \in \mathbb{R}^{1 \times S \times S}$. The image is clamped by a $\tanh$ nonlinearity, average-pooled to $$u = \mathrm{AvgPool}_k(\tilde x) \in \mathbb{R}^{1 \times H \times W}$$ with $H = W = S/k$, and flattened to $f \in \mathbb{R}^F$ where $F = H \cdot W$ (Solanki et al., 16 Mar 2026). Each scalar $f_j$ is then thermometer-encoded into $K$ bits using data-driven quantiles,

$$\tau_{j,k} = \mathrm{Quantile}_{q_k}(\{f_j^{(n)}\}), \qquad q_k = \frac{k}{K+1}.$$

Training uses soft bits

$$b^{\text{soft}}_{j,k} = \sigma\!\left(\frac{f_j - \tau_{j,k}}{T}\right), \qquad T=0.5,$$

while inference uses hard bits

$\tanh$0

The resulting address vector is $\tanh$1 with $\tanh$2.

The core weightless layer consists of $\tanh$3 small RAM-like LUTs. Each $\tanh$4 has an $\tanh$5-bit address with $\tanh$6, so each table has $\tanh$7 entries, and a fixed bit-selection map $\tanh$8 chooses $\tanh$9 bits from $$u = \mathrm{AvgPool}_k(\tilde x) \in \mathbb{R}^{1 \times H \times W}$$0. Lookup yields

$$u = \mathrm{AvgPool}_k(\tilde x) \in \mathbb{R}^{1 \times H \times W}$$1

The output vector $$u = \mathrm{AvgPool}_k(\tilde x) \in \mathbb{R}^{1 \times H \times W}$$2 is passed to a final linear head

$$u = \mathrm{AvgPool}_k(\tilde x) \in \mathbb{R}^{1 \times H \times W}$$3

followed by unit-norm normalization,

$$u = \mathrm{AvgPool}_k(\tilde x) \in \mathbb{R}^{1 \times H \times W}$$4

The training and inference regimes are sharply differentiated. Training keeps the graph differentiable through soft thermometer encoding; only the accessed LUT entries receive gradient updates, described as “localized learning.” The loss is

$$u = \mathrm{AvgPool}_k(\tilde x) \in \mathbb{R}^{1 \times H \times W}$$5

Inference hard-quantizes $$u = \mathrm{AvgPool}_k(\tilde x) \in \mathbb{R}^{1 \times H \times W}$$6, performs pure lookups in the LUT backbone, and uses one small dense layer of $$u = \mathrm{AvgPool}_k(\tilde x) \in \mathbb{R}^{1 \times H \times W}$$7 multiplies. The per-sample gaze error is defined as

$$u = \mathrm{AvgPool}_k(\tilde x) \in \mathbb{R}^{1 \times H \times W}$$8

This architecture is explicitly memory-centric: the LUT backbone incurs zero MACs, and the total inference cost is 131 LUT lookups plus 393 MACs per frame. The paper reports that this design achieves an angular error of $$u = \mathrm{AvgPool}_k(\tilde x) \in \mathbb{R}^{1 \times H \times W}$$9 with only 393 MACs and 2.2 KiB of memory per frame.

3. Gaze-led region selection and compressed edge inference

GLANCE uses the predicted gaze vector $H = W = S/k$0 to derive region proposals for object detection. The 3D gaze is projected to an image-plane fixation $H = W = S/k$1, and an angular gaze uncertainty $H = W = S/k$2 is mapped to a spatial radius

$H = W = S/k$3

For $H = W = S/k$4, $H = W = S/k$5, and $H = W = S/k$6, the reported value is $H = W = S/k$7 px (Solanki et al., 16 Mar 2026). A hit-probability parameter $H = W = S/k$8 defines ROI side length as

$H = W = S/k$9

with $f \in \mathbb{R}^F$0 giving $f \in \mathbb{R}^F$1 px. For each frame $f \in \mathbb{R}^F$2, $f \in \mathbb{R}^F$3 square ROIs $f \in \mathbb{R}^F$4 are formed around $f \in \mathbb{R}^F$5, optionally with micro-saccade offsets, and their spatial union is

$f \in \mathbb{R}^F$6

Instead of processing $f \in \mathbb{R}^F$7 separate crops, GLANCE constructs a Union-of-ROIs mosaic,

$f \in \mathbb{R}^F$8

which extracts the minimal bounding rectangle of $f \in \mathbb{R}^F$9, tiling internally if needed. Temporal accumulation is maintained over $F = H \cdot W$0 frames with decay $F = H \cdot W$1,

$F = H \cdot W$2

At each detector trigger, with $F = H \cdot W$3 in the reported setting, the system builds

$F = H \cdot W$4

and runs YOLOv12n on $F = H \cdot W$5.

Between detector runs, the pipeline uses lightweight IMU-based ROI stabilization. The reported formulation includes rotation-aware reprojection,

$F = H \cdot W$6

and forward-motion inflation,

$F = H \cdot W$7

The deployment model is split between MCU and host. On the MCU, each frame captures an eye image, runs the DWN, produces fixation $F = H \cdot W$8 and proposals $F = H \cdot W$9, and transmits only ROI metadata rather than the full frame. On the host, the system computes $f_j$0, updates $f_j$1, constructs the mosaic $f_j$2, runs YOLOv12n, and sends detections back; cached boxes may be re-aligned until the next refresh. This design is the basis for the reported communication time improvement of $f_j$3, since the system sends 48–80 px crops rather than the full frame.

4. Empirical profile and ablations of GLANCE

For gaze estimation on MPIIGaze under the LOPO protocol, the reported model size is approximately 9.6K parameters, corresponding to 2.2 KiB on-chip with 8-bit thresholds and head parameters and 1-bit LUT entries. On the Arduino Nano 33 BLE at 64\,MHz, the reported latency is $f_j$4 s per frame and the energy is $f_j$5 J per frame; the mean angular error is $f_j$6 (Solanki et al., 16 Mar 2026). The paper contrasts this with CNN baselines such as iTracker at 6.2 mean error and SWCNN at 4.8 mean error, while emphasizing the much smaller MAC and memory footprint of GLANCE.

For detection, the paper states that full-frame YOLOv12n processes 640$f_j$7640 px per frame, whereas GLANCE processes only $f_j$8–$f_j$9 of pixels on average. The reported effects are computation reduced by 40–50\%, energy reduced by 65\%, and end-to-end latency below 10 ms at 60 Hz. The abstract reports 48.1\% mAP on COCO and 51.8\% on attended objects while maintaining sub-10\,ms latency.

The size-stratified comparison with the global YOLOv12n baseline is one of the central reported results. The baseline achieves 39.2\%, 63.4\%, and 83.1\% accuracy for small, medium, and large objects, respectively, whereas the ROI-based method yields 51.3\%, 72.1\%, and 88.1\% under the same settings. In the ablation over ROI count $K$0 and ROI side length $K$1, object size is stratified by area as $K$2 for small, $K$3 for medium, and $K$4 for large. At $K$5, small-object accuracy rises from 29.6 at $K$6 to 51.3 at $K$7, compared with a global value of 42.05. For medium objects at $K$8, the values rise from 53.3 at $K$9 to 72.8 at $$\tau_{j,k} = \mathrm{Quantile}_{q_k}(\{f_j^{(n)}\}), \qquad q_k = \frac{k}{K+1}.$$0, compared with 67.16 globally. For large objects at $$\tau_{j,k} = \mathrm{Quantile}_{q_k}(\{f_j^{(n)}\}), \qquad q_k = \frac{k}{K+1}.$$1, accuracy rises from 47.0 at $$\tau_{j,k} = \mathrm{Quantile}_{q_k}(\{f_j^{(n)}\}), \qquad q_k = \frac{k}{K+1}.$$2 to 90.6 at $$\tau_{j,k} = \mathrm{Quantile}_{q_k}(\{f_j^{(n)}\}), \qquad q_k = \frac{k}{K+1}.$$3, compared with 87.55 globally.

The paper summarizes this behavior as “inverse-scale convergence”: small objects exceed the global baseline earliest, followed by medium, then large. It also reports that ROI patch size $$\tau_{j,k} = \mathrm{Quantile}_{q_k}(\{f_j^{(n)}\}), \qquad q_k = \frac{k}{K+1}.$$4 yields smoother saturation and the highest ceilings. A separate ablation over WNN variants states that increasing LUT address width $$\tau_{j,k} = \mathrm{Quantile}_{q_k}(\{f_j^{(n)}\}), \qquad q_k = \frac{k}{K+1}.$$5 or the number of LUTs $$\tau_{j,k} = \mathrm{Quantile}_{q_k}(\{f_j^{(n)}\}), \qquad q_k = \frac{k}{K+1}.$$6 lowers angular error at higher LUT footprint, while smaller $$\tau_{j,k} = \mathrm{Quantile}_{q_k}(\{f_j^{(n)}\}), \qquad q_k = \frac{k}{K+1}.$$7 such as $$\tau_{j,k} = \mathrm{Quantile}_{q_k}(\{f_j^{(n)}\}), \qquad q_k = \frac{k}{K+1}.$$8 gives error of approximately 10–12$$\tau_{j,k} = \mathrm{Quantile}_{q_k}(\{f_j^{(n)}\}), \qquad q_k = \frac{k}{K+1}.$$9 with less than 1 KiB. A plausible implication is that GLANCE treats gaze estimation accuracy and memory footprint as directly tunable design variables rather than fixed architectural constants.

5. Auto-regressive scanpath prediction architecture

In autonomous navigation, GazeLNN is an auto-regressive scanpath predictor rather than a direct gaze-estimation-and-detection pipeline. The input image $$b^{\text{soft}}_{j,k} = \sigma\!\left(\frac{f_j - \tau_{j,k}}{T}\right), \qquad T=0.5,$$0 is resized to $$b^{\text{soft}}_{j,k} = \sigma\!\left(\frac{f_j - \tau_{j,k}}{T}\right), \qquad T=0.5,$$1, and MobileNetV3-Large is used as the visual feature extractor. The output feature tensor has shape $$b^{\text{soft}}_{j,k} = \sigma\!\left(\frac{f_j - \tau_{j,k}}{T}\right), \qquad T=0.5,$$2 with $$b^{\text{soft}}_{j,k} = \sigma\!\left(\frac{f_j - \tau_{j,k}}{T}\right), \qquad T=0.5,$$3 and $$b^{\text{soft}}_{j,k} = \sigma\!\left(\frac{f_j - \tau_{j,k}}{T}\right), \qquad T=0.5,$$4 (Mohammed et al., 18 Jun 2026).

The recurrent engine is the Closed-Form Continuous-time variant of Liquid Time-Constant Networks. In the paper’s discrete-step notation, with input $$b^{\text{soft}}_{j,k} = \sigma\!\left(\frac{f_j - \tau_{j,k}}{T}\right), \qquad T=0.5,$$5 and elapsed “time” $$b^{\text{soft}}_{j,k} = \sigma\!\left(\frac{f_j - \tau_{j,k}}{T}\right), \qquad T=0.5,$$6, the CfC state update is

$$b^{\text{soft}}_{j,k} = \sigma\!\left(\frac{f_j - \tau_{j,k}}{T}\right), \qquad T=0.5,$$7

Here $$b^{\text{soft}}_{j,k} = \sigma\!\left(\frac{f_j - \tau_{j,k}}{T}\right), \qquad T=0.5,$$8, $$b^{\text{soft}}_{j,k} = \sigma\!\left(\frac{f_j - \tau_{j,k}}{T}\right), \qquad T=0.5,$$9, and $\tanh$00 are small fully-connected networks, and the input-dependent gate $\tanh$01 modulates interpolation between two nonlinear transforms.

The model predicts fixation heatmaps sequentially. It initializes $\tanh$02 and a center heatmap $\tanh$03, described as a fixed Gaussian at image center. At each step $\tanh$04, it computes backbone features $\tanh$05, concatenates $\tanh$06 into $\tanh$07, updates the hidden state via the CfC cell, and decodes a downsampled heatmap $\tanh$08. After upsampling and normalization,

$\tanh$09

the next fixation is selected as

$\tanh$10

The paper writes the resulting dependence as

$\tanh$11

This architecture uses fixation history explicitly through both $\tanh$12 and the shared hidden state. The resulting model is therefore not a saliency map estimator in the static sense, but a sequential predictor of scanpaths.

6. Computational efficiency, benchmarks, and ablations of the scanpath model

The reported computational budget is 0.61 GFLOPs end-to-end. The paper decomposes this into approximately 0.55 GFLOPs for the MobileNetV3 backbone on a $\tanh$13 input, 0.03 GFLOPs for CoordConv, projection, and upsampling, and approximately 0.03 GFLOPs per time step for the CfC recurrent module with four fully-connected layers of 512 units and gating. For an 8-step scanpath, the paper gives the nominal sum

$\tanh$14

while noting that the recurrent FCs are cached, and reports an empirically measured total of 0.61 GFLOPs (Mohammed et al., 18 Jun 2026).

The principal baseline is tSPM-Net, identified as the strongest prior recurrent model in the paper. Table III reports 102.51 GFLOPs per image for tSPM-Net, versus 0.61 GFLOPs for GazeLNN, corresponding to a 99.40\% reduction in FLOPs. On an NVIDIA RTX 3500Ada GPU, the reported inference times are 43.90 ms/frame for tSPM-Net and 6.84 ms/frame for GazeLNN, which the paper expresses as an approximately $\tanh$15 speed-up and real-time operation at approximately 150 Hz for up to eight fixations.

On the MIT Low Resolution dataset, consisting of 168 images and 8 subjects, GazeLNN is evaluated with six scanpath metrics: Levenshtein distance, ScanMatch score, Hausdorff distance, Fréchet distance, FastDTW, and Time Delay Embedding. The reported values are LD $\tanh$16, SM $\tanh$17, HD $\tanh$18, FD $\tanh$19, FastDTW $\tanh$20, and TDE $\tanh$21. The paper contrasts these with tSPM-Net’s SM $\tanh$22, HD $\tanh$23, FD $\tanh$24, FastDTW $\tanh$25, and TDE $\tanh$26, and states that GazeLNN improves the ScanMatch score by 34.3\% and reduces curve and time-series distances by up to 38\%.

The ablations distinguish backbone choice from recurrent-module choice. With the same CfC and training, VGG19 + DeepLabV3 gives approximately 99.8 GFLOPs, SM $\tanh$27, and 17.4 ms inference; ResNet50 + DeepLabV3 gives approximately 69.8 GFLOPs, SM $\tanh$28, and 14.3 ms; MobileNetV3 + DeepLabV3 gives approximately 62.1 GFLOPs, SM $\tanh$29, and 13.8 ms; ResNet50 without DeepLab gives approximately 8.3 GFLOPs, SM $\tanh$30, and 7.4 ms; MobileNetV3 without DeepLab gives approximately 0.61 GFLOPs, SM $\tanh$31, and 6.8 ms, and is the chosen configuration. For recurrent modules under the VGG19 + DeepLabV3 backbone, Bayesian ConvLSTM gives SM $\tanh$32, approximately 102.5 GFLOPs, and 43.9 ms; ConvLSTM gives SM $\tanh$33, approximately 102.5 GFLOPs, and 21.8 ms; CfC gives SM $\tanh$34, approximately 99.8 GFLOPs, and 17.4 ms, and is the chosen recurrent engine.

7. Integration into fixation-guided active perception

The navigation paper embeds GazeLNN inside a reinforcement-learning policy that jointly controls robot motion and camera orientation. The observation is

$\tanh$35

and the action is

$\tanh$36

The per-step reward is

$\tanh$37

where

$\tanh$38

$\tanh$39

$\tanh$40

and

$\tanh$41

The fixation-attraction term is intended to keep predicted salient regions near the image center (Mohammed et al., 18 Jun 2026).

The policy architecture uses a small ResNet-style heatmap encoder for $\tanh$42, a frozen Deep Collision Encoder for depth, and a lightweight CNN for the local 3D occupancy grid; the embeddings are concatenated with robot state and passed through an MLP, a GRU, and two heads for navigation and camera angles. Training is performed in the Aerial Gym simulator using Asynchronous PPO with domain randomization, and images are downsampled to $\tanh$43 to save compute.

Real-world deployment uses a quadrotor with a two-axis pan-tilt RealSense D455 camera and an on-board NVIDIA Jetson Orin NX. The paper reports GazeLNN at approximately 150 Hz and the control policy at 10 Hz. Relative to a static forward-facing camera, the fixation-guided policy accumulates 55 524 full-scene voxels versus 37 067, observes 6 770 voxels in predicted salient regions versus 873, and increases maximum hit counts on key features from 537 to 756.

Taken together, the two 2026 usages of GazeLNN define a coherent research direction around efficient, explicit attention guidance. In GLANCE, the emphasis is memory-centric lookup-based gaze estimation coupled to ROI-restricted detection. In autonomous navigation, the emphasis is recurrent scanpath prediction coupled to active camera control. A plausible implication is that “GazeLNN” is becoming associated less with one network topology than with a systems strategy: approximate human attention economically enough that it can directly structure perception on resource-constrained platforms.