LiCoNet: Lightweight KWS Model

• LiCoNet is a lightweight neural architecture built on MobileNetV2-style inverted residuals and linear bottlenecks, designed for streaming keyword spotting.
• It is deployed in both query-by-example systems using spectral-temporal graph attentive pooling and as LiCoNet-S on MCUs under strict latency, memory, and energy constraints.
• Empirical results highlight its efficiency—achieving competitive FRR and F1 scores with significantly fewer parameters compared to models like Conformer—while detailed topology remains less specified.

Searching arXiv for LiCoNet and related keyword spotting papers. LiCoNet is a lightweight, hardware-efficient, streaming convolutional neural network for keyword spotting (KWS) that has been studied in both query-by-example and embedded microcontroller settings. In the recent literature considered here, LiCoNet appears as a convolution-only encoder derived from MobileNetV2-style inverted residual and linear bottleneck design, and as LiCoNet-S, a compact variant evaluated for MCU deployment under strict latency, memory, and energy constraints. Across these uses, its defining characteristics are streaming-friendly causal or streaming-origin convolutions, reduced parameter count, and suitability for on-device inference over time-frequency speech features (Wang et al., 2024, Bartoli et al., 8 Sep 2025).

1. Definition and terminological scope

In KWS research, LiCoNet denotes a neural architecture rather than a networking or line-coding scheme. The strongest paper-specific usage is in speech models: one study uses LiCoNet as the encoder in a query-by-example KWS system, and another evaluates LiCoNet-S as one of several lightweight models for embedded MCU keyword spotting (Wang et al., 2024, Bartoli et al., 8 Sep 2025).

A recurrent source of confusion is that the same string can be informally associated with unrelated interconnect topics. Two relevant papers explicitly do not use the term “LiCoNet.” One introduces Low-Energy Line Codes (LELCs) for on-chip networks, and states that if “LiCoNet” is used elsewhere for line-coding in NoCs or OCNs, it would correspond only to the architectural integration of those LELCs rather than to the paper’s own terminology (Dabak et al., 2024). Another introduces LACIN (Linearly Arranged Complete Interconnection Networks) and likewise states that the paper itself does not use “LiCoNet”; any equivalence is a naming substitution rather than the paper’s adopted term (Beivide et al., 9 Jan 2026).

Accordingly, the primary technical meaning supported by the KWS literature is LiCoNet as a speech encoder architecture. The networking usages are best treated as terminological analogies, not as established authorial definitions.

2. Architectural formulation for keyword spotting

LiCoNet is described as a hardware-efficient, streaming convolutional network built on MobileNetV2’s inverted residual and linear bottleneck design, adapted for KWS. In the query-by-example system, each LiCo-Block is a bottleneck comprising three 1D convolutional layers: a streaming 1D convolution with kernel size greater than 1 for local temporal context, a point-wise 1D convolution for channel mixing, and a second point-wise 1D convolution projecting back to a lower-dimensional bottleneck. The reported encoder uses 5 LiCo-Blocks, expansion factor 6, and kernel size 5 for the streaming convolution in each block (Wang et al., 2024).

The architectural rationale is explicitly tied to KWS deployment constraints. Temporal locality is prioritized through the streaming convolution, which suits causal operation and low latency; spectral interaction is handled through $1 \times 1$ channel mixing rather than through more expensive attention or 2D kernels; and the design emphasizes equivalent linear operators for inference so that streaming execution avoids heavy matrix transposes or self-attention (Wang et al., 2024).

The MCU study presents a more deployment-oriented description. There, the evaluated model is LiCoNet-S, cited from earlier work and described in its original form as a streaming-inference architecture with causal convolutions for low-latency KWS on constrained devices. For the benchmark, LiCoNet-S is adapted from streaming to one-shot inference by changing the padding strategy so that the full utterance can be processed without maintaining internal state. The classification head, as for all evaluated models in that study, is global average pooling followed by a fully connected layer with softmax activation (Bartoli et al., 8 Sep 2025).

An important negative fact is that the MCU paper does not provide a layer-by-layer topology for LiCoNet-S. Exact kernel sizes, strides, numbers of channels, activations, normalization, and bottleneck or expansion settings are not reported there. This makes the architecture far better specified in the query-by-example paper than in the MCU benchmarking paper (Bartoli et al., 8 Sep 2025).

3. LiCoNet in query-by-example KWS

In the query-by-example formulation, LiCoNet serves as the encoder in an encoder-decoder training setup. The encoder maps 2-second word segments of 40-dimensional log-Mel filterbank energies into fixed-length embeddings, and these embeddings are then aggregated by spectral-temporal graph attentive pooling (GAP). The input features use a 25 ms frame length and 10 ms frame shift; training segments are standardized to 2 s via clipping or zero-padding; and the training set contains 1002 targets, defined as the top-1k frequent words plus Silence and Unknown (Wang et al., 2024).

The GAP mechanism operates over time-frequency encoder maps. The graph is built from time-frequency cells $x_{t,f}$, represented as node vectors $h_i \in \mathbb{R}^D$, with temporal, spectral, and spectro-temporal attention blocks. The reported graph pooling ratios are 0.71 for spectral pooling, 0.86 for temporal pooling, and 0.71 for spectro-temporal pooling. The attention follows standard graph-attention form:

$$e_{ij} = \mathrm{LeakyReLU}\!\left(a^T[Wh_i \,\|\, Wh_j]\right),$$

$$\alpha_{ij} = \frac{\exp(e_{ij})}{\sum_{k \in N(i)} \exp(e_{ik})},$$

$$h'_i = \sigma\!\left(\sum_{j \in N(i)} \alpha_{ij}Wh_j\right).$$

After the three graph-attention blocks, the pooled node set is aggregated into a single embedding by attention-weighted mean or statistics pooling (Wang et al., 2024).

Training uses multi-task learning. The word-discrimination objective is either Additive Angular Margin loss or SoftTriplet loss; speaker regularization is imposed by a reverse speaker loss through a Gradient Reversal Layer; and frame-level phoneme supervision is added with an AAM loss. The hybrid objective is reported as

$$L(x,y)=L_{\text{word}}(x,y^w)-\eta L_{\text{aam}}(x,y^s)+\mu L_{\text{aam}}(x,y^p),$$

with $\eta = 0.1$ and $\mu = 0.5$. For AAM, the paper reports $m=0.2$ and $x_{t,f}$0; for SoftTriplet, it reports $x_{t,f}$1, $x_{t,f}$2, and $x_{t,f}$3 prototypes per class (Wang et al., 2024).

The runtime query pipeline is also explicitly defined. Enrollment uses 3 utterances per keyword. A sliding window over streaming audio is encoded by LiCoNet, pooled by GAP, and compared to the enrollment embeddings by cosine distance,

$x_{t,f}$4

The score is the minimum distance across the 3 enrollment samples,

$x_{t,f}$5

and a detection is declared when $x_{t,f}$6, with $x_{t,f}$7 swept to produce DET curves and operating points such as false reject rate (FRR) at 0.3 false accepts per hour (FAs/Hr) (Wang et al., 2024).

4. LiCoNet-S in embedded MCU keyword spotting

The embedded study evaluates LiCoNet-S as part of an end-to-end KWS pipeline that includes waveform ingestion, MFCC extraction, neural inference, and a negligible post-processing step. The task is treated as single-utterance classification rather than continuous detection, and no smoothing or wake-word decision logic is described. The dataset is Google Speech Commands Dataset v0.02 with 10 keyword classes: yes, no, up, down, left, right, on, off, stop, and go. Noise from GSCD, including synthetic and real background sounds, is mixed at $x_{t,f}$8 (Bartoli et al., 8 Sep 2025).

The feature extractor uses MFCCs, with four evaluated configurations formed by the Cartesian product of Mel filter-bank counts $x_{t,f}$9 and frame counts $h_i \in \mathbb{R}^D$0. The two frame counts align with short-time FFT sizes of 1024 and 512, respectively, chosen to avoid zero-padding and enable efficient computation. The paper states that the MFCC matrices are processed as inputs of size $h_i \in \mathbb{R}^D$1, but it does not specify channel ordering, sampling rate, frame length, hop length, window function, pre-emphasis, delta features, or normalization specifics beyond the fact that the features are normalized prior to neural classification (Bartoli et al., 8 Sep 2025).

As background, and not specifically stated in that paper, the MFCC pipeline may be written as

$h_i \in \mathbb{R}^D$2

$h_i \in \mathbb{R}^D$3

$h_i \in \mathbb{R}^D$4

$h_i \in \mathbb{R}^D$5

$h_i \in \mathbb{R}^D$6

These equations provide standard signal-processing context for the MFCC front end used with LiCoNet-S (Bartoli et al., 8 Sep 2025).

Deployment is benchmarked on three STM32 platforms: STM32 N6 with Cortex-M55 at 800 MHz and integrated NPU, STM32 H7 with Cortex-M7 at 480 MHz, and STM32 U5 with Cortex-M33 at 160 MHz. MFCC extraction uses each platform’s DSP. All models, including LiCoNet, are quantized to 8-bit integers, although the quantization scheme and whether quantization-aware or post-training quantization is used are not specified (Bartoli et al., 8 Sep 2025).

The study evaluates end-to-end efficiency via the energy-delay product,

$h_i \in \mathbb{R}^D$7

where $h_i \in \mathbb{R}^D$8 is energy in mJ and $h_i \in \mathbb{R}^D$9 is latency in ms. A central conclusion is that model accuracy alone does not determine deployability: the cost of MFCC pre-processing plus inference, and the compatibility of layer shapes with platform DSP or NPU support, are decisive for practical MCU KWS (Bartoli et al., 8 Sep 2025).

5. Empirical performance and efficiency

For embedded KWS, the paper reports LiCoNet-S parameter counts and weighted F1 scores under four MFCC settings. The F1-score is

$$e_{ij} = \mathrm{LeakyReLU}\!\left(a^T[Wh_i \,\|\, Wh_j]\right),$$0

MFCC configuration	Parameters	Weighted F1
15×32	17.4k	90.1%
30×32	18.3k	90.3%
15×63	17.4k	93.6%
30×63	18.3k	92.5%

These results show that LiCoNet-S reaches its best reported embedded performance at $$e_{ij} = \mathrm{LeakyReLU}\!\left(a^T[Wh_i \,\|\, Wh_j]\right),$$1, with 17.4k parameters and 93.6% weighted F1. Moving from 32 to 63 frames improves LiCoNet-S in both Mel settings, while increasing Mel filters from 15 to 30 has a mixed effect. This suggests LiCoNet is more sensitive to time resolution than spectral resolution in the reported MCU setup. The same paper notes that TKWS-3 can match or nearly match LiCoNet-S with fewer parameters, for example 92.4% versus 93.6% at $$e_{ij} = \mathrm{LeakyReLU}\!\left(a^T[Wh_i \,\|\, Wh_j]\right),$$2 with 14.4k versus 17.4k parameters (Bartoli et al., 8 Sep 2025).

System-level results qualify the accuracy numbers. The N6 platform achieves the best overall EDP because fast DSP-based MFCC extraction is paired with low-power, high-speed NPU inference. On H7 and U5, whose EDPs are described as broadly similar, H7 offers lower latency but higher energy, whereas U5 offers lower energy but higher latency. The paper further states that on MCUs without NPUs, 1D convolutional models tend to be more energy-efficient than 2D models; DS-CNN shows the highest EDP on H7 and U5; and on N6, TENet models can suffer higher EDP when kernel sizes exceed the NPU’s optimal execution range and trigger CPU offloading (Bartoli et al., 8 Sep 2025).

In the query-by-example setting, LiCoNet is characterized more fully in computational terms. It has 694K parameters and 46.5M FLOPs per 2-second audio segment, compared with 1.4M parameters and 642.2M FLOPs for Conformer, and 540K parameters and 39.1M FLOPs for ECAPA_TDNN. The paper reports LiCoNet as “13x more efficient” than Conformer, and the explicit FLOP ratio is approximately $$e_{ij} = \mathrm{LeakyReLU}\!\left(a^T[Wh_i \,\|\, Wh_j]\right),$$3 (Wang et al., 2024).

Under the best multi-task configuration with GAP and word SoftTriplet, LiCoNet achieves 1.98% FRR at 0.3 FAs/Hr, versus 1.63% for Conformer and 5.58% for ECAPA_TDNN. The LiCoNet ablation sequence reported in the paper is also informative: Word CE with attentive statistics pooling gives 13.20% FRR; Word AAM gives 9.75%; adding reverse speaker loss gives 7.49%; adding phoneme loss gives 5.36%; replacing ASP with GAP gives 3.63%; and replacing AAM with SoftTriplet under GAP gives the best 1.98% (Wang et al., 2024).

6. Interpretation, deployment implications, and limitations

The two KWS studies support a consistent interpretation of LiCoNet as a compact architecture whose practical value depends strongly on surrounding system design. In the query-by-example setting, its raw encoder efficiency is not sufficient by itself; the reported gains depend on spectral-temporal graph attentive pooling and the hybrid training objective with word, speaker, and phoneme supervision. In the embedded setting, deployment quality is not reducible to weighted F1 alone; MFCC extraction, quantization, hardware support for specific operators, and end-to-end EDP are equally central (Wang et al., 2024, Bartoli et al., 8 Sep 2025).

Several practical implications follow directly from the embedded study. For LiCoNet-S on MCUs, higher temporal resolution in the MFCC front end should be favored over simply increasing the number of Mel filters; $$e_{ij} = \mathrm{LeakyReLU}\!\left(a^T[Wh_i \,\|\, Wh_j]\right),$$4 is identified as a strong operating point; int8 quantization is used throughout; and, where available, the STM32 N6 is preferred because DSP-assisted MFCC extraction and NPU inference yield the best overall EDP. The same study recommends verifying that LiCoNet layer or kernel shapes are compatible with NPU execution, since CPU fallback increases data-movement overhead (Bartoli et al., 8 Sep 2025).

The main limitations are also explicit. For LiCoNet-S in the MCU paper, exact layer-by-layer topology, MAC counts, SRAM footprint, detailed latency and energy values, precision and recall, confusion matrices, training hyperparameters, and quantization granularity are not reported. For the query-by-example paper, strides, dilations, normalization, activation choices, and exact graph adjacency construction parameters are likewise not specified. Runtime or hardware latency measurements are not provided there, even though the model is described as streaming and hardware-friendly by construction (Bartoli et al., 8 Sep 2025, Wang et al., 2024).

A final encyclopedic caution concerns nomenclature. In speech KWS, LiCoNet refers to a lightweight neural encoder family. In the interconnect papers cited alongside it, the term is absent, and the correct paper-specific names are LELCs and LACIN. Treating those topics as direct instances of LiCoNet obscures domain boundaries rather than clarifying them (Dabak et al., 2024, Beivide et al., 9 Jan 2026).