Rethinking Temporal Models for TinyML: LSTM versus 1D-CNN in Resource-Constrained Devices

This paper demonstrates that 1D Convolutional Neural Networks are a superior alternative to LSTMs for TinyML applications on resource-constrained devices, offering comparable or higher accuracy while significantly reducing memory usage and inference latency.

The Gist

Imagine you have a tiny, battery-powered smartwatch that needs to recognize when you're running, sleeping, or typing. To do this, it needs a "brain" (a computer model) that can look at a stream of data over time and figure out what's happening.

For a long time, the go-to brain for this job was called an LSTM. Think of an LSTM like a scholarly librarian. This librarian is incredibly smart; they read every single book (data point) in the library, remember the plot of every story, and understand how the beginning connects to the end. They are great at understanding complex stories. However, this librarian is heavy, requires a massive library building (lots of memory), and takes hours to check out a single book (very slow). Trying to fit this librarian into a tiny wristwatch is like trying to stuff a full library into a backpack; it's too heavy, drains the battery instantly, and the watch would freeze while waiting for the librarian to think.

The authors of this paper asked: "Do we really need a full-time librarian for a simple task like recognizing a walk?"

They tested a different kind of brain called a 1D-CNN. Think of this one as a super-fast security guard. The security guard doesn't read the whole book. Instead, they scan the hallway for specific patterns: "Is the person moving fast? Is the arm swinging?" They spot these local patterns instantly. They don't need a massive library; they just need a small notepad. They are lightweight, run on a tiny battery, and make decisions in the blink of an eye.

The Big Showdown: The Library vs. The Guard

The researchers put both the "Librarian" (LSTM) and the "Security Guard" (1D-CNN) to the test on five different real-world scenarios (like recognizing human movements or heartbeats) using a tiny, cheap computer chip (the ESP32) found in many IoT devices.

Here is what happened:

1. Accuracy (Who is smarter?):
   Surprisingly, the Security Guard (1D-CNN) was just as smart, or even smarter, than the Librarian. In fact, the Guard got the right answer about 95% of the time, while the Librarian only got it right about 89% of the time.

   • The Twist: When the researchers tried to shrink the models to make them fit on the tiny chip (a process called "quantization"), the Librarian got confused and made many mistakes. The Security Guard, however, stayed sharp and accurate even when shrunk down.

2. Memory (How much space do they take?):
   The Librarian needed a huge amount of space (RAM and Flash memory) to hold all their notes. The Security Guard needed 35% less RAM and 25% less storage space.

   • Analogy: It's like the Librarian needs a mansion to live in, while the Guard fits perfectly in a cozy studio apartment.

3. Speed (How fast are they?):
   This was the biggest difference. The Librarian took 2,038 milliseconds (over 2 seconds) to make a single decision. If your watch used the Librarian, it would freeze every time you moved.
   The Security Guard took only 27.6 milliseconds. That is nearly 75 times faster.

   • Analogy: The Librarian is like a snail taking a nap; the Guard is a cheetah on caffeine.

The Conclusion

The paper concludes that for tiny devices like smartwatches, fitness trackers, and medical sensors, we don't need the heavy, slow "Librarian" (LSTM) anymore.

The 1D-CNN (Security Guard) is the perfect choice. It is:

• Lighter: Fits easily on cheap chips.
• Faster: Makes real-time decisions without freezing.
• Smarter: Actually gets better results in many cases.
• Battery-Friendly: Doesn't drain your device's power.

In short: If you are building a tiny, battery-powered device, stop trying to force a giant brain into a small box. Use the lightweight, fast, and efficient 1D-CNN instead. It's the practical, everyday hero for the world of TinyML.

Technical Summary

Here is a detailed technical summary of the paper "Rethinking Temporal Models for TinyML: LSTM versus 1D-CNN in Resource-Constrained Devices" by Bidyut Saha and Riya Samanta.

1. Problem Statement

Time-series classification is critical for IoT applications such as human activity recognition (HAR), gesture detection, and healthcare monitoring. While Long Short-Term Memory (LSTM) networks are the standard for capturing temporal dependencies, they face significant barriers in TinyML (Tiny Machine Learning) deployment:

• Resource Constraints: Microcontroller Units (MCUs) typically have limited SRAM (a few hundred KB) and Flash storage (<1 MB). LSTMs are computationally heavy and memory-intensive, making real-time on-device inference impractical.
• Cloud Dependency: Current workarounds often offload processing to the cloud or edge, which introduces latency, increases energy consumption, raises infrastructure costs, and compromises data privacy.
• The Gap: There is a lack of hardware-aware, "apples-to-apples" comparisons between LSTMs and lighter alternatives (like 1D-CNNs) specifically optimized for strict MCU constraints, including the effects of quantization.

2. Methodology

The authors conducted a rigorous, hardware-aware feasibility study comparing 1D-Convolutional Neural Networks (1D-CNN) against LSTMs.

• Datasets: Five benchmark datasets were used, covering three domains:
  • Human-Computer Interaction/Lifestyle: UCI-HAR, PAMAP2, WISDM (IMU signals).
  • Healthcare: MIT-BIH Arrhythmia, PTB Diagnostic ECG (ECG signals).
• Model Architectures:
  • 1D-CNN: Implemented using depthwise separable convolutions for efficiency. It consists of three convolutional layers (32, 48, 72 filters; kernel size 3) with max pooling, followed by global average pooling, a dense layer (72 units), dropout, and softmax.
  • LSTM: A stacked LSTM architecture with matching unit counts (32, 48, 72) to capture long-range dependencies, followed by similar dense and output layers.
• Training Protocol: Both models used identical optimizers, batch sizes, and epoch budgets. Hyperparameters were tuned via grid search on validation sets to prevent test leakage.
• Optimization & Deployment:
  • Quantization: Models were evaluated in both Float32 (non-quantized) and INT8 (post-training quantized) formats using the TensorFlow Model Optimization Toolkit.
  • Hardware: All inference metrics were measured on an ESP32 MCU (240 MHz) using the TensorFlow Lite Micro framework.
• Metrics: Classification accuracy, RAM usage, Flash size, and inference latency (ms).

3. Key Contributions

1. Hardware-Aware Comparison: Provided a direct, capacity-controlled comparison of LSTM vs. 1D-CNN specifically for TinyML environments, moving beyond theoretical accuracy to practical deployability.
2. Comprehensive Evaluation Protocol: Established a benchmark covering accuracy, memory footprint (RAM/Flash), latency, and the impact of INT8 quantization on MCUs.
3. Empirical Evidence: Demonstrated across five diverse datasets that 1D-CNNs are superior to LSTMs for on-device processing, challenging the assumption that LSTMs are necessary for temporal tasks in resource-constrained settings.

4. Key Results

The study yielded decisive results favoring 1D-CNNs across all metrics:

• Accuracy:
  • 1D-CNN achieved an average accuracy of 95.49% (Float32) and 95.36% (INT8).
  • LSTM achieved 89.52% (Float32) and dropped significantly to 85.53% (INT8).
  • Observation: 1D-CNNs are more robust to quantization, suffering negligible accuracy loss, whereas LSTMs degrade significantly when converted to INT8.
• Memory Efficiency:
  • RAM: 1D-CNNs required ~35% less RAM (Avg: 19.85 KB vs. 30.29 KB for LSTM).
  • Flash: 1D-CNNs required ~25% less Flash (Avg: 94.66 KB vs. 123.46 KB for LSTM).
• Inference Latency (Critical Finding):
  • 1D-CNN: Achieved real-time performance with an average latency of 27.6 ms.
  • LSTM: Suffered prohibitive latency with an average of 2038.2 ms (over 2 seconds per inference).
  • Implication: LSTMs are effectively non-real-time on this hardware, while 1D-CNNs are suitable for interactive applications.

5. Significance and Conclusion

The paper establishes that 1D-CNNs are the superior choice for TinyML time-series classification on resource-constrained devices.

• Practicality: 1D-CNNs offer a "sweet spot" of high accuracy, low memory footprint, and real-time latency, making them ideal for battery-operated wearables and low-power systems.
• Paradigm Shift: The results suggest that for many temporal tasks, the complex recurrent mechanisms of LSTMs are unnecessary and counter-productive on MCUs. The local pattern extraction capabilities of 1D-CNNs, especially when combined with depthwise separable convolutions and INT8 quantization, provide a more efficient and robust solution.
• Future Outlook: While the current study focuses on ~2-second sequences at 50Hz, the authors propose extending this work to longer sequences and higher-frequency data to further validate the versatility of 1D-CNNs in the TinyML ecosystem.