🤖 machine learning

A Feature Extraction Pipeline for Enhancing Lightweight Neural Networks in sEMG-based Joint Torque Estimation

This paper proposes a feature extraction pipeline using 8-channel sEMG signals that enables a lightweight Multilayer Perceptron to achieve joint torque estimation performance comparable to a Temporal Convolutional Network, offering a promising solution for data-limited robot-assisted rehabilitation scenarios.

Original authors: Kartik Chari, Raid Dokhan, Anas Homsi, Niklas Kueper, Elsa Andrea Kirchner

Published 2026-02-13

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Kartik Chari, Raid Dokhan, Anas Homsi, Niklas Kueper, Elsa Andrea Kirchner

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a robot arm to help a person lift a heavy box. To do this safely, the robot needs to know exactly how hard the person's muscles are pushing at every moment. If the robot guesses wrong, it might push too hard and hurt the person, or not push enough and drop the box.

This paper is about building a better "translator" to help the robot understand the person's muscles.

The Problem: The Noisy Whisper

The researchers use sEMG (surface electromyography), which is like sticking tiny microphones on a person's skin to listen to the electrical "whispers" of their muscles.

The problem is that these whispers are messy. They are full of static, background noise, and they change depending on how tired the person is or how heavy the object is. Usually, to make sense of this noise, you need a super-complex, heavy computer brain (a deep neural network) that takes a long time to train and needs thousands of examples to learn.

But in a hospital or rehab center, you don't have thousands of patients, and you don't want a computer that takes up a whole room. You need something lightweight, fast, and simple that works with very little data.

The Solution: The "Feature Extraction Pipeline"

The authors created a special preprocessing step they call a Feature Extraction Pipeline. Think of this as a high-end kitchen prep station.

Instead of throwing raw, muddy vegetables (the raw muscle signals) directly into the pot (the robot's brain), this pipeline:

Washes and peels the vegetables (removes noise and static).
Chops them into perfect, uniform cubes (extracts specific patterns like muscle strength and rhythm).
Seasons them (normalizes the data so a light lift and a heavy lift are understood correctly).

By doing this "prep work," the ingredients are so clean and organized that even a very simple chef can cook a gourmet meal.

The Experiment: The Simple Chef vs. The Master Chef

To test their idea, the researchers set up a race between two "chefs" (computer models):

The Simple Chef (MLP): A basic, lightweight neural network. It's like a junior cook who is great at following recipes but doesn't have a lot of experience with timing or complex flavors.
The Master Chef (TCN): A Temporal Convolutional Network. This is a highly specialized, complex AI designed specifically to understand the timing and sequence of events. It's like a Michelin-star chef who knows exactly how a flavor changes over time.

The Setup:
A healthy volunteer sat in a chair and lifted weights (0kg, 1.1kg, and 1.85kg) while moving their arm. The researchers recorded the muscle signals and calculated the actual force (torque) the arm was producing.

The Results:

Without the Prep Station: If you give the "Simple Chef" the raw, muddy data, it struggles.
With the Prep Station: When the researchers fed the "Simple Chef" the data that had gone through their special pipeline, something magical happened. The Simple Chef performed just as well as, and sometimes even better than, the Master Chef.

Why This Matters

The big takeaway is that you don't always need a super-complex brain if you have great data.

The Analogy: Imagine trying to guess the weather.
- Old Way: You give a super-computer raw satellite images, wind speeds, and humidity readings from 100 years ago. It takes forever to process, and it's still confused.
- New Way: You give a simple calculator a clean, pre-processed report that says, "It's raining, wind is 10mph, humidity is 90%." The simple calculator gets the answer instantly and correctly.

The Real-World Impact

This is a game-changer for robot-assisted rehabilitation.

Less Data Needed: You don't need to record hours of data from hundreds of patients. A simple model with this pipeline can learn from just a few sessions.
Faster & Cheaper: Lightweight models can run on small, portable devices (like a wristband) rather than needing a massive server.
Personalized Care: Since the model is simple, it can be quickly re-trained for each individual patient, adapting to their specific muscle quirks without needing a supercomputer.

In short: The paper shows that by cleaning up the signal first, you can use a simple, fast, and cheap computer to control a rehabilitation robot just as well as a massive, expensive, complex one. It's about working smarter, not harder.

1. Problem Statement

Robot-assisted rehabilitation requires exoskeletons to adapt to user needs by accurately predicting joint torques in real-time. Traditional approaches face significant challenges:

Musculoskeletal Models: Methods like Hill-type models require complex parameter estimation and specialized equipment, making them difficult to construct and deploy.
Deep Learning Limitations: While Recurrent Neural Networks (RNNs) and Temporal Convolutional Networks (TCNs) excel at modeling temporal dependencies in raw sEMG data, they typically require large datasets and computationally expensive architectures. This is impractical in clinical settings where patient fatigue limits data collection, and training data is often scarce.
The Gap: There is a need for a method that can achieve high-accuracy torque prediction using lightweight models (suitable for edge devices) and limited data, without sacrificing the ability to capture complex temporal muscle dynamics.

2. Methodology

A. Experimental Design

Participant & Setup: Data was collected from one healthy male subject performing elbow and shoulder movements under three load conditions (0 kg, 1.10 kg, 1.85 kg).
Sensors:
- sEMG: 8-channel bipolar surface EMG signals recorded from the right arm (deltoid, biceps, triceps, brachialis, pectoralis major) at 500 Hz.
- Motion Capture: Three Qualisys cameras tracked 3D joint trajectories using passive markers at 500 Hz.
Tasks: Two movement types were performed: simple grasping (sagittal plane extension) and complex movements (combined flexion/extension and abduction/adduction).
Reference Torque Calculation: Ground truth torques were estimated using a static equilibrium method based on kinematic data and segment masses (Upper Arm, Forearm, Hand), assuming negligible wrist rotation and dynamic effects.

B. Proposed Feature Extraction Pipeline

The core contribution is a dedicated pipeline transforming raw sEMG into discriminative features, designed to be compatible with simple feedforward networks. The pipeline includes:

Preprocessing:
- Removal of baseline offsets using resting EMG.
- Zero-phase 4th-order Butterworth band-pass filtering (15–225 Hz).
- Variance-based filtering to capture amplitude fluctuations.
- Normalization: Condition-specific normalization (scaling 0–1 based on max amplitude per weight/movement condition) was found superior to global normalization.
- Low-pass filtering (5 Hz) for smoothing.
Neural Activation Modeling:
- Application of a second-order difference equation to model the electromechanical delay ( $d$ ) between EMG activity and muscle force production.
Feature Extraction (Time, Frequency, Time-Frequency):
- Time-domain: RMS, Waveform Length (WL), Slope Sign Change (SSC).
- Frequency-domain: Band Power (BP) via Multitaper method.
- Time-frequency: Morlet Wavelet Transform (MWT) to capture non-stationary spectral evolution.
Postprocessing:
- Sliding window segmentation (100 ms, 50% overlap).
- History stacking to provide temporal context.
- Dimensionality reduction via Principal Component Analysis (PCA).
- One-hot encoding for categorical variables (weight/movement type).

C. Machine Learning Models

Two models were compared to evaluate the pipeline's efficacy:

Multilayer Perceptron (MLP): A lightweight feedforward network (Input $\to$ Hidden Layers with ReLU $\to$ Output with Tanh). It uses weighted Huber loss to handle imbalanced torque variances.
Temporal Convolutional Network (TCN): A state-of-the-art architecture explicitly designed for sequence modeling using causal and dilated convolutions. It was tested with both raw time points and the proposed feature pipeline.

3. Key Contributions

Feature Extraction Pipeline: A comprehensive pipeline that extracts rich temporal, spectral, and time-frequency features from sEMG, effectively encoding muscle dynamics without requiring complex recurrent architectures.
Lightweight Model Performance: Demonstrated that a simple MLP, when fed with these engineered features, can achieve performance comparable to or better than a TCN designed for temporal dependencies.
Condition-Specific Normalization: Identified that normalizing data based on specific load/movement conditions significantly outperforms global normalization, especially when including low-load (0 kg) data.
Data Efficiency: The approach is specifically tailored for scenarios with limited training data, a common constraint in patient care.

4. Results

The study evaluated performance using Root Mean Squared Error (RMSE), Pearson's correlation coefficient ( $\rho$ ), and Coefficient of Determination ( $R^2$ ) across five random seeds.

Normalization Impact: Condition-specific normalization (Condition B) significantly improved MLP performance over global normalization (Condition A), particularly for the elbow and front-shoulder joints when 0 kg data was included.
MLP vs. TCN (Raw Data): When TCN used only raw preprocessed time points, it performed slightly worse than the MLP using the full feature pipeline.
MLP vs. TCN (Feature Pipeline):
- MLP (with pipeline): Achieved mean RMSE of 0.963 N·m (Elbow), 1.403 N·m (Front-Shoulder), and 1.434 N·m (Side-Shoulder).
- TCN (with pipeline): Achieved slightly lower RMSE (0.933, 1.459, 1.314 respectively), but the MLP results were statistically comparable.
- Correlation: The MLP achieved higher Pearson's $\rho$ values (e.g., 0.926 vs. 0.924 for elbow), indicating it captured temporal dynamics effectively despite being a feedforward model.
Conclusion on Models: The feature pipeline allowed the simple MLP to match the TCN's performance, proving that the extracted features successfully encoded the necessary temporal information.

5. Significance

Clinical Applicability: By enabling high-accuracy torque estimation using lightweight models (MLP), this approach reduces computational requirements, making it feasible for deployment on resource-constrained wearable devices or embedded systems in rehabilitation robots.
Data Scarcity Solution: The method is robust even with limited training data (single subject, short duration), addressing a major bottleneck in personalized rehabilitation where collecting large datasets is often impossible due to patient fatigue.
Future Direction: The authors suggest that this pipeline serves as a strong baseline for future work involving inverse dynamics for reference torque calculation, online real-time implementation, and systematic multi-subject user studies.