LITEWAY: LIghtweight HAR via Temporal Efficient highWAY

arXiv:2608.09421 · cs.LG, cs.AI, cs.HC · Submitted 2026-08-10 · Read on arXiv

Listen

Transcript

Introduction to the show: ident: Paper Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: Next we'll be talking about the paper "LITEWAY: LIghtweight HAR via Temporal Efficient highWAY".

Jane: The paper was written by Dominique Nshimyimana, Vitor Fortes Rey, Mengxi Liu, Bo Zhou and Paul Lukowicz from RPTU and DFKI.

Tom: Stay tuned as we take you through the paper and discuss its implications.

Paper summary: Tom: Okay, we're starting with a new paper today, and honestly the headline is pretty striking. The authors built a human activity recognition model that's fully convolutional, so no recurrent layers at all, and it runs on a tiny microcontroller using a fraction of the energy of previous state-of-the-art models.

Jane: And the accuracy doesn't fall off a cliff, which is the surprising part. Over sixteen datasets, their full model reaches a macro F1 of 0 point 813, actually the highest of everything they compared against.

Tom: Wait, higher than the bigger models too?

Jane: Yeah, higher than all four baselines, including ones with far more parameters. The Light version is barely behind at 0 point 808, but it only needs about 989,000 multiply-accumulate operations and 6,500 parameters.

Lu: The interesting design choice is replacing recurrent networks like GRUs and LSTMs with structured convolutions. Recurrent models process time steps one after another, which is slow and power-hungry, and this paper argues that's the wrong tool for wrist-worn sensors.

Meng: Right, and the core module they designed merges ideas from gated units and highway networks, but with shared projections so you don't duplicate parameters. That shared-projection trick is what keeps the parameter count so low. The outcome shows up clearly in the deployment tests.

Lalam: And that's the real point here. It's not just another compression trick. It's a question about what architecture actually fits the hardware constraints of wearables, and the evidence suggests you can get the temporal modeling you need from convolutions alone.

Tom: The deployment numbers are concrete. On an STM32 microcontroller, the Light model runs an inference in 37 milliseconds using under three millijoules. The smallest baseline they compare against needs 81 milliseconds and more than six millijoules.

Lu: So that's roughly a two to three times energy reduction, and several times smaller in memory. For a device running on a coin cell battery, that difference can mean weeks of extra operation.

Meng: And the breadth is impressive too. Sixteen datasets covering accelerometers, gyroscopes, magnetometers, even ECG. This isn't tuned to one sensor setup.

Lalam: They even ran a Bayesian statistical test to back up the accuracy claims. The evidence says they're at least on par with existing lightweight models and probably better, while being dramatically smaller. That combination is what matters in practice.

Jane: There's a lot of subtle design detail underneath, though, about where residuals help, why attention pooling matters, and which activation functions earn their compute. We should go back to the beginning and see how the introduction frames all of this.

Tom: Good plan. Page one sets up the problem and the contributions, so that's where we start.

Page 1 of the paper: Jane: So page one opens with the problem statement. Wearable devices have limited memory, compute, and battery, but high-performing HAR models are hungry on all three fronts, and the applications affected are healthcare, sports analytics, smart homes, and industrial safety monitoring.

Tom: And they're direct about the culprit. They name DeepConvLSTM as the dominant paradigm, pairing convolutional layers for local features with recurrent layers for sequence modeling. It works well, but the recurrent part is sequential by nature and doesn't parallelize.

Lu: The sequential computation issue is worth spelling out. With an LSTM, each time step depends on the previous hidden state, so you wait for step one before step two, and that latency adds up on a chip that's already slow.

Meng: The paper also mentions recent lightweight models, TinyHAR, TinierHAR, and MLP-HAR, but says many still rely on recurrent temporal modeling or expensive feature extraction. MLP-HAR drops the recurrent part, but it's not fully end-to-end learnable.

Jane: That last point is interesting. What does "not fully end-to-end" mean exactly?

Meng: The paper doesn't elaborate on page one, but it's a stated limitation of that baseline, and it sets up the gap they want to fill.

Lalam: Their contributions are fourfold: a fully convolutional framework, a lightweight architecture for wearable HAR, an evaluation on sixteen datasets showing major size reductions, and deployment evidence showing lower energy use.

Tom: The abstract gives the headline numbers already. Depending on variant and baseline, model size drops by roughly four to nine and a half times, and energy reductions reach more than three times on the Light version.

Lu: The naming matters too. Light and Full map directly to the efficiency versus accuracy trade-off. Full is a bit bigger and scores barely higher, Light is the extreme low-cost setting.

Lalam: What I find clever is that they're not just claiming "small model, decent accuracy." They're claiming the architecture itself, the way temporal information flows through it, is better suited to the hardware constraint.

Tom: And the keywords place it squarely in embedded systems territory: edge eye, time series, computing methodologies. This is not a pure theory paper.

Jane: There's still a gap between the claims and the architecture at this point. The real design rationale starts on page two, where they go deeper into related work and then begin the methodology.

Tom: Right, so let's move to page two, because that's where the model actually starts to take shape.

Page 2 of the paper: Tom: Page two finishes the related work with a closer look at those lightweight architectures. TinyHAR optimized for edge deployment, TinierHAR and SPECTRA pushing complexity down further, and the paper argues none of them fully solves the joint problem of temporal receptive field, inference latency, and model compactness.

Jane: Then the methodology starts, and the architecture has three main pieces: a feature extraction backbone, the SCTM temporal module, and a lightweight classification head. The backbone alone is six convolutional blocks in two stages.

Lu: The first stage does temporal downsampling with residual blocks using batch norm and leaky ReLU. The first block applies a residual depthwise convolution, the second a depthwise separable convolution, and each is followed by pointwise mixing.

Meng: So the time dimension shrinks early, which saves compute in every later layer. Then the second stage, four blocks, refines features using depthwise separable convolutions with squeeze-and-excitation attention.

Tom: The squeeze-and-excitation part is a nice detail. It learns which channels matter and recalibrates them, and they implement it with 1x1 convolutions so the whole thing stays fully convolutional.

Jane: The Light variant takes a different route. It replaces the regular convolutions and pooling with strided depthwise convolutions, which combine feature extraction and downsampling in a single operation, and it drops the SE modules to save compute.

Lu: And they're honest about the cost. The paper says the SE removal causes a tolerable performance loss, and later we'll see exactly how tolerable.

Lalam: There's a clear philosophy running through this. Every component has a stated purpose: reduce temporal resolution early, avoid expensive transformations, refine features efficiently. Nothing exists just because it worked in a bigger network.

Meng: The SCTM module is teased as the core, but the actual details come on page three. I'm curious how they build a gated highway-style temporal model without recurrence.

Tom: They also preview their efficiency principles: strided convolutions to replace pooling, 1D convolutions instead of recurrent models, lightweight activations, and selective residual connections.

Jane: That last one is the subtle claim. Residuals don't belong everywhere. The ablations later show exactly where they do belong, but that's page five material.

Lalam: So the architecture is set up, and the SCTM module is clearly the centerpiece. Page three should show us how it actually works.

Tom: Right, and that's exactly where we're headed next.

Page 3 of the paper: Tom: So page three is the heart of the architecture. SCTM stands for Structured Convolutional Temporal Modeling, and the Full version is essentially a highway network rebuilt with convolutions and shared weights.

Jane: Let me try to say this in plain language. You take the input, run a depthwise temporal convolution, then apply a single shared pointwise projection. From that projection you derive two signals: a gated tanh unit, where a sigmoid decides what passes through and tanh does the transformation, plus a carry stream using the complement of that same gate, like the carry gate in a highway network.

Lu: The key efficiency trick is the shared projection. A standard gated linear unit learns two separate weight matrices, one for the gate and one for the filter. Here they tie them together, so one projection serves both pathways, and that cuts the parameter count substantially.

Meng: And they fuse the two streams by concatenation, not addition like classic residual connections. Concatenation keeps the two representations separate so later layers can learn how they interact, which is the split-transform-merge idea from Inception.

Lalam: The gate is also derived from processed temporal features rather than the raw input. So the gating decision already knows something about time, which is more useful than just channel statistics.

Tom: Then there's the Light variant of SCTM. It applies the depthwise convolution, a pointwise projection with GELU activation, and adds a residual pathway projected with ELU, then concatenates. No separate gate multiplication, so fewer operations.

Jane: After SCTM comes the classification head. They use attention-based temporal pooling with a single learnable projection that assigns importance weights to each time step, then a weighted sum, then one linear layer. That single linear layer is the only one in the whole network.

Lu: That's a strong statement about where the capacity lives. Almost everything is convolutional.

Meng: The efficiency choices on this page reinforce it. Strided convolutions replace pooling, 1D convolutions avoid hidden state, activations are picked for cost, and residuals appear only where needed.

Lalam: The parameter discipline is remarkable. The Full model has 6 point 7 thousand parameters, the Light model 6 point 5 thousand. Some HAR models from a few years ago had millions.

Tom: Then the page moves into the experiment setup, and this is where the evaluation becomes serious. Sixteen datasets, subject-independent protocols, and a careful training schedule.

Jane: The results come next, and that's where we find out if all this careful design actually pays off.

Page 4 of the paper: Tom: Page four opens with the table of sixteen datasets, covering accelerometers, gyroscopes, magnetometers, even ECG and body capacitance. Sampling rates go from 20 to 100 hertz, and window lengths from one to four seconds, so it's a genuinely broad test bed.

Jane: The evaluation protocol is strict, and that matters. It's subject independent, meaning the model gets tested on people it never trained on. For most datasets that's leave-one-subject-out, and the two largest use group-based hold-out to keep training time reasonable.

Lu: There's one exception worth mentioning. The skodar dataset has a single subject, so they use leave-one-session-out instead. It's a sensible adaptation, and the paper flags it rather than hiding it.

Meng: Training details are fully specified. Five random seeds with averaged results, up to 150 epochs, AdamW, early stopping with patience fifteen. Macro F1 is the primary metric because the datasets are class imbalanced.

Lalam: And the baselines are four: TinyHAR, TinierHAR, MLP-HAR, and DeepConvLSTM, all running under the same protocol. That's how they can claim a fair comparison, which matters because a lot of HAR papers cherry-pick evaluation setups.

Tom: The per-dataset results are honest because neither variant wins everything. The Light version gets top-two macro F1 on nine of the sixteen datasets, the Full version on ten, and there are hard datasets like oppo and oppoloc where every method scores low.

Jane: The aggregate tells the clearer story. Full averages 0 point 813, Light 0 point 808, and the best baseline, MLP-HAR, sits at 0 point 807. So they win on average, but the margin is small. The margin in efficiency, though, is not small.

Lu: Right, the efficiency gap is enormous. Light needs about 989,000 MACs and 6 point 5 thousand parameters. The smallest baseline by compute is TinierHAR at roughly two and a half million MACs, and TinyHAR is far above that.

Meng: So they're cutting compute by factors ranging from two and a half up to over a hundred, depending on which baseline and which metric you look at.

Lalam: The trade-off analysis on this page makes a deeper point. Adding parameters and MACs doesn't reliably improve accuracy in this regime, so the standard reflex of scaling up models doesn't pay off.

Tom: There's a second observation too. Parameter count is a poor proxy for computational cost. Two models can have similar parameter counts but very different MACs, because operation types and data movement matter more than raw weight count.

Jane: That's a genuinely useful insight for the field. And the page ends by setting up the ablation study, testing residuals, channel recalibration, aggregation strategies, and activation functions.

Tom: Those ablations are on page five, along with the real hardware deployment results, which is where things get really concrete.

Page 5 of the paper: Tom: Page five opens with the design ablations, and the headline is that the Full model scores 81 point 3 F1, and every single modification makes it worse. Removing residuals costs 0 point 7 points, switching to the light temporal module costs 0 point 7, and replacing convolutional attention with max-mean pooling costs the most, down to 79 point 7.

Jane: The pooling result is a big deal. They compare three aggregation strategies: convolutional attention, which they use, linear attention, which TinyHAR and TinierHAR use, and max-mean pooling. Linear attention nearly matches at 80 point 8, but max-mean pooling clearly hurts.

Lu: The activation ablation is surprisingly subtle. Homogeneous GELU gives 80 point 6, homogeneous Leaky ReLU gives 80 point 5, and swapping GELU for Leaky everywhere drops to 80 point 4 but cuts MACs from 1 point 4 million to 978,000. Their heterogeneous mix, where different blocks use different activations, gets 80 point 8 at 989K MACs.

Meng: So block-wise activation assignment beats any uniform choice, on both accuracy and cost. That's the kind of engineering detail that doesn't make headlines but genuinely matters on hardware.

Lalam: The residual ablation tells a similarly sharp story. No residuals at all: 80 point 1 at 904K MACs. Residuals everywhere: 80 point 0 at 1 point 3 million MACs. Residuals only in the early layers: 80 point 8 at 989K. So blanket residuals don't help, and placement matters.

Tom: Then comes the deployment table, which might be the most compelling part of the whole paper. They put all five models on an STM32L4S5 microcontroller running at 120 megahertz and measure latency, memory, CPU load, and energy.

Jane: The numbers are stark. TinyHAR needs 249 milliseconds per inference and 19 point 14 millijoules. MLP-HAR runs 114 milliseconds and 8 point 73 millijoules. TinierHAR, the previous efficiency leader, does 81 milliseconds and 6 point 36 millijoules.

Lu: The new models run in 56 point 71 and 37 point 44 milliseconds, with 4 point 35 and 2 point 90 millijoules respectively. So the Light model is more than twice as fast and uses less than half the energy of TinierHAR.

Meng: The memory numbers are just as impressive. Light uses 10 point 07 kilobytes of weights and about 16 kilobytes of activation memory. That fits comfortably in the SRAM of a small microcontroller, which is often the real constraint.

Lalam: There's an honest caveat in the table. The new architecture has a higher number of cycles per multiply-accumulate than some baselines, so each operation is less hardware-friendly. But because it needs so many fewer operations overall, the total cost still comes out far lower.

Tom: That's a good nuance, because it shows they're not hiding weaknesses. They measure everything, and the architecture wins on total cost despite being less efficient per operation.

Jane: So we have the full picture now: competitive accuracy, dramatically lower compute, and verified energy savings on real hardware. Page six steps back to discuss the statistics, the design insights, and the limits of the approach.

Page 6 of the paper: Tom: Page six opens with the statistical analysis, and it's refreshingly rigorous. They run a Bayesian signed-rank test across the sixteen datasets, defining a region of practical equivalence of one F1 point.

Jane: The results are honest. The probability that the Full variant outperforms each baseline ranges from 0 point 59 to 0 point 86, and the probability that any baseline beats it is at most 0 point 13. But none of those comparisons crosses the 0 point 95 threshold needed for a decisive claim.

Lu: So they conclude the architecture is at least on par with the state of the art and most likely superior, while being substantially smaller. It's careful language, and I respect that they don't overclaim.

Meng: Then they revisit the efficiency-accuracy trade-off and place both variants on the Pareto frontier. The point about scale is worth repeating. Bigger models in this comparison don't reliably give better accuracy, so the scaling instinct doesn't pay off here.

Lalam: The design insights section condenses the lessons into four claims. Residuals belong in early layers. Attention-based aggregation beats simple pooling. Temporal modeling is still essential. And heterogeneous activations beat uniform ones. Each claim maps to a specific ablation they ran.

Tom: The limitations section is also refreshingly direct. They only tested on a single microcontroller, so hardware generalization is open. They didn't explore quantization or pruning, which could push efficiency further. And they didn't tune SCTM depth or kernel size.

Jane: I appreciate that they flag the cycle-per-MAC inefficiency as future work. That means there's still headroom within their own architecture if someone can make those operations more hardware friendly.

Lu: And the future work list includes multi-sensor fusion. Their datasets already combine modalities like accelerometer, gyroscope, and magnetometer, but they haven't yet designed specifically for how sensors relate to each other.

Meng: The conclusion wraps it up. Recurrent architectures replaced with structured convolutions, substantial reductions in compute and size, and verified low energy and fast inference on resource-constrained hardware.

Lalam: I'd add that the funding context matters too. Sustainable embedded eye and a cross-activity project. This is a direction with real backing, not just academic curiosity.

Tom: There's also an implication beyond HAR. If temporal modeling with convolutions is this efficient, similar designs might work for other continuous sensor tasks like gesture recognition or on-device audio classification.

Jane: Let's hold that thought for the wrap-up, because there's a lot to tie together.

Conclusion: Tom: So let's wrap up. The paper makes a clear case that you don't need recurrent networks to model time in wearable activity recognition, and the evidence is both broad and deep.

Jane: Sixteen datasets, five seeds, subject-independent evaluation, four baselines, real hardware deployment, and a Bayesian analysis on top. That's a thorough empirical package, and the verdict is that a fully convolutional design matches or slightly beats the state of the art while being dramatically cheaper.

Lu: The concrete numbers stay with me. The Light variant uses 6 point 5 thousand parameters, under a million MACs, runs in 37 milliseconds, and costs under three millijoules per inference. Against the smallest baseline, that's more than a two times reduction in both latency and energy.

Meng: And the design insights are actionable. Shared projections in gated blocks, concatenation instead of addition, residuals only in early layers, attention pooling, heterogeneous activations. These are ideas other researchers can lift directly for their own efficient models.

Lalam: The bigger picture is that hardware constraints are shaping architecture choices again. A lot of the recent progress in machine learning has been driven by scaling up, and this paper demonstrates the opposite direction: asking what structure gives the most information per operation.

Tom: The obvious next steps are named in the paper itself. Quantization, pruning, hardware-specific acceleration, deeper exploration of the temporal module. If those squeeze out another two or three times in efficiency, the same design becomes viable for even smaller devices.

Jane: I also want to credit the honest framing. They didn't claim to crush every baseline on accuracy. They claimed parity or better with a fraction of the resources, and they provided the evidence for that specific claim.

Lu: The public code helps too. Anyone working on wearable HAR can test this on their own sensor setup, which is how the field will actually validate the approach further.

Meng: The one open thread I'd watch is multi-sensor fusion. The datasets cover many modalities, but the architecture treats channels uniformly. If they design specifically for how sensors relate, there might be another accuracy gain available.

Lalam: And for the broader community, the lesson is about reporting standards. Deployment measurements, energy numbers, memory footprints, and honest statistics should be the norm for embedded eye papers, not the exception.

Tom: We've covered the architecture, the ablations, the hardware results, and the limitations, so it's time to say goodbye to this paper. Thanks to the team in Kaiserslautern for making the source code available.

Jane: And thanks to our listeners for staying with us. We've got another paper from the same area coming up next, so the conversation continues.

Tom: Until then, take care.

Dominique Nshimyimana, Vitor Fortes Rey, Mengxi Liu, Bo Zhou, Paul Lukowicz

RPTU · DFKI

cs.LG, cs.AI, cs.HC

Submitted: 2026-08-10

Updated: 2026-08-11

Comments: accepted at UbiComp / ISWC 2026

Code: https://github.com/dominique-nshimyimana/liteway

License: http://creativecommons.org/licenses/by-nc-nd/4.0/

Importance score: 95/100

The gist: LITEWAY is a modality-agnostic, fully convolutional framework for multichannel sensor time series that replaces recurrent temporal modeling with structured convolutional decomposition.

Key concepts

Fully convolutional model: A neural network that uses only convolutional layers, no recurrent layers like LSTM or GRU. This allows parallel processing and reduces computational cost, making it suitable for low-power devices like microcontrollers.
SCTM (Structured Convolutional Temporal Modeling): The core module of LITEWAY. It uses a shared pointwise projection to derive both a gated tanh unit and a carry stream, mimicking highway networks but with convolutions. This shared projection reduces parameters while maintaining temporal modeling.
Macro F1 score: A metric that averages F1 scores across all classes, treating each class equally. It is used because the datasets are class-imbalanced, providing a fair measure of model performance.
Subject-independent evaluation: A testing protocol where the model is tested on individuals it has never seen during training. This ensures the model generalizes to new users, which is critical for real-world wearable applications.

Terminology

Accuracy — 18× in this paper · explained in 1 episode
Ablation — 10× in this paper · explained in 1 episode
F1 Score — 9× in this paper · explained in 3 episodes
Feature Extraction — 7× in this paper · explained in 2 episodes
Generalization — 7× in this paper · explained in 13 episodes
Activation Function — 6× in this paper · explained in 1 episode
Aggregation — 5× in this paper · explained in 1 episode
Edge Devices — 2× in this paper · explained in 2 episodes
Pruning — 2× in this paper · explained in 4 episodes
Quantization — 2× in this paper · explained in 12 episodes
Structured Convolutional Temporal Modeling — 2× in this paper
Ablation Studies — 1× in this paper · explained in 1 episode
Ablation study — 1× in this paper · explained in 1 episode
Adam — 1× in this paper · explained in 2 episodes
AdamW Optimizer — 1× in this paper · explained in 1 episode
Adaptation — 1× in this paper · explained in 1 episode
Core — 1× in this paper · explained in 2 episodes
Decoupling — 1× in this paper · explained in 2 episodes
Distillation — 1× in this paper · explained in 2 episodes
Edge AI — 1× in this paper · explained in 2 episodes
Edge Deployment — 1× in this paper · explained in 2 episodes
Generative Model — 1× in this paper · explained in 2 episodes
Knowledge Distillation — 1× in this paper · explained in 11 episodes
Latent Representation — 1× in this paper · explained in 2 episodes
Robustness — 1× in this paper · explained in 5 episodes

Summary

LITEWAY is a modality-agnostic, fully convolutional framework for multichannel sensor time series that replaces recurrent temporal modeling with structured convolutional decomposition. It combines lightweight convolutional blocks, strided temporal processing, and convolution-attention pooling to efficiently capture temporal dependencies while reducing computational complexity. The model has three components: (i) a feature extraction backbone that downsamples and refines features using residual and depthwise-separable convolutions with attention-based channel recalibration; (ii) a Structured Convolutional Temporal Modeling (SCTM) module capturing long-range dependencies via depthwise convolutions, shared projections, and gated pathways without recurrence; (iii) a lightweight classification head that aggregates features via attention-based pooling followed by a linear layer.

The paper evaluates LITEWAY on 16 HAR datasets against TinyHAR, TinierHAR, and MLP-HAR. LITEWAY achieves competitive macro F1 while reducing model size by 4.06×–9.52× (Light) and 3.87×–9.07× (Full) compared with TinyHAR and TinierHAR. Deployment experiments further show energy reductions of 2.29×–3.14× (Light) and 1.46×–2.01× (Full) compared with TinierHAR and MLP-HAR, highlighting efficient fully convolutional temporal modeling for wearable HAR.

Among all methods, LITEWAY Full achieves the highest macro F1-score (0.813), followed by LITEWAY Light (0.808). Both models outperform existing baselines, including TinierHAR (0.801), TinyHAR (0.805), MLPHAR (0.807) and DeepConvLSTM (0.801). In terms of efficiency, LITEWAY Light requires the lowest cost (988.8K MACs) and model size (6.5K parameters), while LITEWAY Full maintains a similarly compact footprint with only a small increase in complexity. Compared to existing baselines, this corresponds to reductions of approximately 2.51×–146× in MACs and 4.06×–176× in parameters.

The LITEWAY Light variant achieves top-2 macro F1 scores on 9 out of 16 datasets. It ranks first on mhealth, motionsense, and recgym, and achieves second place on dsads, hapt, pamap2, realdisp, sho, and skodar. Similarly, the LITEWAY Full variant reaches top-2 performance on 10 datasets, securing first place on dg, motionsense, and pamap2, and second place on dsads, hapt, mhealth, realdisp, rw, sho, and skodar.

Ablation studies show that residual connections, SCTM, and ConvAtt are critical for high macro F1, while efficient blocks allow LITEWAY Light to maintain strong performance with minimal resource demand. Removing or simplifying components generally reduces macro F1: NoRes and SCTM-L decrease macro F1 by 0.7 points, while MMX achieves the lowest macro F1 (79.7), highlighting the importance of ConvAtt aggregation. LITEWAY Light achieves a favorable trade-off, reducing MACs by over 45% relative to the full model, with only a minor macro F1 drop (from 81.3 to 80.8).

Regarding activation functions, mixed activations yield better accuracy–efficiency balance than uniform designs. Activation functions have limited impact on accuracy (≤ 0.2 F1 variation) but affect computation. Leaky ReLU lowers MACs compared to GELU, and GELU→Leaky reduces computation from 1.4M to 978K MACs without changing parameter count. The proposed LITEWAY Light achieves the best trade-off, obtaining the highest macro F1 score (80.8) with low cost (989K MACs).

Regarding residual connections, selective residual connections in early layers are sufficient for stable optimization in lightweight HAR models. NoRes achieves the lowest execution cost (904K MACs) with slightly fewer parameters while maintaining competitive performance (80.1 F1). Res-All increases computation (1.3M MACs, 6.8K params) without improving accuracy (80.0 F1), indicating limited benefit from applying residuals uniformly across all layers. LITEWAY achieves the best trade-off (80.8 F1) with near-NoRes cost (989K MACs, 6.5K params).

On hardware deployment using the STM32L4S5 microcontroller, LITEWAY Light achieves the best overall efficiency, requiring only 37.44 ms per inference, 3% CPU load, and 2.90 mJ per inference. Compared with TinierHAR, it reduces both latency and energy by more than 2×, while using only 10.07 KiB of weights, corresponding to approximately 4× smaller parameter footprint. LITEWAY Full requires 56.71 ms per inference, 5% CPU load, and 4.35 mJ per inference.

The paper also reports a Bayesian signed-rank test on per-dataset macro-F1 scores across the 16 datasets, using a region of practical equivalence (ROPE) of one F1 point. For LITEWAY-F, the posterior probability of outperforming each baseline ranges from 0.59 to 0.86 and never favours a baseline (all P(baseline better) ≤ 0.13); since no comparison crosses the conventional 0.95 decision threshold, the authors conclude that the architecture is at least on par with, and most likely superior to, the SOTA baselines while remaining substantially smaller.

The paper's contributions are: (i) proposing LITEWAY, a fully convolutional HAR framework that replaces RNN with structured convolutional decomposition, enabling efficient temporal modeling and being resource-aware; (ii) introducing a lightweight architecture optimized for wearable HAR, balancing memory, compute, and representation capacity via modular convolutional blocks; (iii) evaluating on 16 datasets, where LITEWAY achieves competitive macro F1, with the Light and Full variants reducing model size by 4.06×–9.52× and 3.87×–9.07×, respectively, compared to TinierHAR and TinyHAR; (iv) ablation and deployment showing LITEWAY Light maximizes efficiency with 2.29×–3.14× lower energy, while LITEWAY Full improves macro F1 with 1.46×–2.01× lower energy, both versus TinierHAR and MLP-HAR.

Limitations noted include evaluation on a single microcontroller, which may limit generalization across hardware, and not exploring further optimizations such as quantization, pruning, hardware-specific acceleration, or architectural choices including SCTM depth, kernel size, and multi-sensor fusion.

Improvements for AI systems

Improvements to AI Systems:

Replace recurrent layers with structured convolutional decomposition (SCTM) in any time-series model (e.g., HAR, speech, biosignal processing) to capture long-range dependencies without recurrence, reducing MACs by 2.51×–146× and parameters by 4.06×–176× while maintaining or improving accuracy.
Adopt depthwise-separable convolutions with attention-based channel recalibration in feature extraction backbones to reduce computational cost and model size, enabling deployment on resource-constrained microcontrollers (e.g., STM32L4S5) with <3% CPU load and 2.9 mJ per inference.
Use convolution-attention pooling (ConvAtt) instead of global average pooling or recurrent pooling in classification heads, as ablations show it improves macro F1 by up to 1.6 points (e.g., from 79.7 to 81.3) with minimal added cost.
Apply selective residual connections only in early layers rather than uniformly across all layers, reducing MACs by 24% (from 1.3M to 989K) without sacrificing accuracy, based on the finding that Res-All provides no benefit over selective residuals.
Choose mixed activation functions (e.g., Leaky ReLU over GELU) to cut computation by 30% (from 1.4M to 978K MACs) with negligible F1 change (≤0.2), improving energy efficiency for edge AI.
Use the LITEWAY Light architecture as a default for wearable/edge HAR to achieve top-2 macro F1 on 9 of 16 datasets with only 6.5K parameters and 988.8K MACs, reducing energy by 2.29×–3.14× versus existing baselines.

What the Improved AI System Can Do:

Run real-time human activity recognition on battery-powered wearables (e.g., smartwatches, fitness bands) with inference latency under 40 ms and energy consumption below 3 mJ per inference, enabling continuous monitoring for days on a single charge.
Process multi-channel sensor streams (accelerometer, gyroscope, magnetometer) on-device without cloud offloading, preserving privacy and reducing latency, while achieving state-of-the-art accuracy (macro F1 = 0.808–0.813) across diverse datasets (e.g., motion, health, gesture recognition).
Scale to 16+ heterogeneous datasets without retuning, thanks to modality-agnostic design, making it suitable for general-purpose sensor analytics in health monitoring, smart homes, and industrial IoT.
Deploy on low-power microcontrollers with limited memory (e.g., 10 KiB weights) and no GPU, making AI accessible to ultra-low-cost hardware, and enabling future optimizations like quantization or pruning for even further efficiency gains.

Abstract

Wearable human activity recognition (HAR) remains challenging due to the computational and energy constraints of deep learning models on resource-limited devices. Existing lightweight approaches often rely on recurrent architectures (e.g., GRU and LSTM), limiting parallelism and increasing inference latency. We propose LITEWAY, a modality-agnostic, fully convolutional framework for multichannel sensor time series that replaces recurrent temporal modeling with structured convolutional decomposition. LITEWAY combines lightweight convolutional blocks, strided temporal processing, and convolution-attention pooling to efficiently capture temporal dependencies while reducing computational complexity. We evaluate LITEWAY on 16 HAR datasets against TinyHAR, TinierHAR, and MLP-HAR. LITEWAY achieves competitive macro F1 while reducing model size by 4.06x-9.52x (Light) and 3.87x-9.07x (Full) compared with TinyHAR and TinierHAR. Deployment experiments further show energy reductions of 2.29x-3.14x (Light) and 1.46x-2.01x (Full) compared with TinierHAR and MLP-HAR, highlighting efficient fully convolutional temporal modeling for wearable HAR. The source code is publicly available at https://github.com/dominique-nshimyimana/liteway.