XceptionTime: sEMG Gesture Recognition

• XceptionTime is a deep learning architecture for sEMG-based gesture recognition that leverages depthwise separable convolutions, adaptive pooling, and μ-law normalization to extract joint spatial-temporal features.
• The model employs Inception-style modules with parallel kernels and skip-connections to reduce parameters while efficiently capturing diverse features from multichannel sEMG signals.
• It achieves state-of-the-art accuracy on the Ninapro DB1 dataset with a 93.91% test accuracy and a 4.6-fold parameter reduction, ensuring robustness to window length variability and temporal shifts.

XceptionTime is a deep learning architecture specifically designed for hand gesture classification from sparse multichannel surface electromyography (sEMG) signals. The model integrates depthwise separable convolutions, adaptive average pooling, and a novel μ-law non-linear normalization method to jointly extract spatial and temporal features across channels and time, while maintaining robustness to window length variability and temporal translation. XceptionTime sets a new state-of-the-art for sEMG-based gesture recognition with substantially fewer parameters than conventional CNN-based approaches, as demonstrated on the Ninapro DB1 dataset of 52 gestures captured from 10 sEMG channels (Rahimian et al., 2019).

1. Network Architecture and Core Components

XceptionTime processes a windowed data segment of length $W$ ms (e.g., 200 ms) from $C = 10$ sEMG channels sampled at 100 Hz; thus, the network input is an array of $T=W \cdot 100$ time samples. Its primary building block is the XceptionTime Module, featuring two parallel computation paths designed to efficiently capture feature diversity:

• Path A (Inception-style):

1. 1×1 bottleneck convolution reduces $C_{in} \to f$ channels.
2. Three parallel depthwise-separable Conv1D operations with kernel sizes $\ell_1=11$, $\ell_2=21$, $\ell_3=41$, each outputting $f$ channels.

• Path B (Skip-connection/Mixer):

1. MaxPooling1D (kernel size 3, stride 1).
2. 1×1 convolution producing $f$ channels.

The four $f$-channel outputs from the three kernels and the pooling path are concatenated, yielding $C_{out} = 4f$ channels.

The full XceptionTime network consists of four stacked modules with intermediate residual connections (1×1 convolution plus BatchNorm) and ReLU activation. The filter sizes in successive modules are $f = 16,32,64,128$. Two Adaptive Average Pooling (AAP) layers ensure model invariance to window length: the first reduces the time dimension to 50, the second collapses it to 1. Final layers consist of three 1×1 convolutional layers (with BatchNorm and ReLU), ultimately producing a 52-dimensional output vector for softmax-based classification.

2. Depthwise Separable Convolutions: Structure and Parameter Efficiency

Standard 1D convolutions with $C_{in} \rightarrow C_{out}$ channels and kernel size $K$ require $C_{in} \cdot C_{out} \cdot K$ parameters. XceptionTime employs depthwise separable convolutions, reducing parameter count as follows:

• Depthwise step: $C_{in}$ separate $K$-length filters ($C_{in} \cdot K$ parameters).
• Pointwise step: a 1×1 convolution mixes channels ($C_{in} \cdot C_{out}$ parameters).

Total parameters per layer: $C_{in} \cdot K + C_{in} \cdot C_{out}$.

With $C_{in}=f$ and $C_{out}=f$ in XceptionTime:

$\text{Params}_{\text{DSConv}} = f \cdot K + f^{2}$

This structure leads to a total parameter count of approximately 413,516 for the network at $W=200$ ms, a 4.6-fold reduction compared to the 1,918,476 parameters required by an otherwise identical architecture using regular 1D convolutions.

3. Novel μ-Law Non-Linear Normalization

Each sEMG signal sample $x_t$ undergoes a μ-law non-linear normalization prior to convolutional processing. The transformation, with $\mu = 256$, is defined as:

$$F(x_t) = \text{sign}(x_t) \cdot \frac{\ln(1 + \mu |x_t|)}{\ln(1 + \mu)}$$

This normalization stretches small-magnitude signal values (increasing SNR) and compresses large-magnitude values, directly improving model robustness and accuracy, especially for short time windows. Empirically, replacing μ-law with MinMax normalization degrades accuracy by up to 10 percentage points for short input windows.

4. Adaptive Average Pooling and Temporal/Window Robustness

Adaptive Average Pooling (AAP) enables the network to maintain invariance to the input segment length. For an input feature map $H(c, t)$ over time indices $t=1 \ldots L_{in}$, output bins $i=1 \ldots L_{out}$ are computed as:

$$H'(c, i) = \frac{1}{|S_i|} \sum_{t \in S_i} H(c, t)$$

with partitions $S_i$ covering $[1, L_{in}]$ evenly. This process supports:

• Temporal translation invariance: Temporal shifts in input only alter the average content of the corresponding pooled bin.
• Window length independence: Changes in window size $L_{in}$ require no architectural changes or retraining.

In XceptionTime, AAP first compresses the time axis to 50, enabling window-agnostic processing, and finally reduces it to length 1 for final classification.

5. Training Protocol and Dataset

• Dataset: Ninapro sub-DB1, comprising 27 able-bodied subjects, 52 gesture classes, 10 sEMG channels sampled at 100 Hz.
• Windowing: Input segmented into 200 ms windows via a sliding window with a 10 ms stride.
• Train/Test Split: Repetitions 2, 5, and 7 are reserved for the test set; the remaining seven are used for training.
• Preprocessing: First-order Butterworth low-pass filter at 1 Hz, followed by μ-law normalization.
• Optimization: Adam optimizer with initial learning rate $\eta = 0.001$; the learning rate is halved every 20 epochs using a cyclical schedule.
• Batch size: 32.
• Loss: Categorical cross-entropy.
• Activations: ReLU; BatchNorm after each convolution; residual summations included.

6. Quantitative Evaluation and Comparative Results

XceptionTime achieves an average test accuracy of 93.91% on Ninapro DB1 for the 200 ms window, an absolute improvement of 5.71 percentage points over the prior best (PLOS2018 hybrid CNN-RNN at ~88.20%). Additional results:

Method	Accuracy (%)	Params (approx.)
Geng et al. (2016)	79.45	—
Wei et al. (2017)	82.53	—
PLOS2018 (Hu et al.)	92.39	—
Atzori2016 (Conv-only)	80.20	—
ICASSP2019 (TCN)	71.81	—
TBE2019 (Multi-view CNN)	90.24	—
XceptionTime	93.91	413,516
XceptionTime-V2 (no DSConv)	94.59	1,918,476

Training XceptionTime on a mix of window lengths $\{50, 100, 150, 200\}$ ms yields further gains in robustness and generalization. The deployment of μ-law normalization is especially beneficial for shorter windows.

7. Advantages, Limitations, and Prospective Work

Advantages

• Joint spatial and temporal feature extraction from multi-channel sEMG data without manual feature engineering.
• Substantial regularization and overfitting resistance via bottlenecks, depthwise separable convolutions, and BatchNorm, without reliance on large fully connected layers.
• Empirical independence from window length and resilience to temporal signal shifts due to adaptive average pooling.
• Lightweight model (<0.5M parameters), compatible with real-time prosthetic control scenarios.

Limitations and Future Directions

• Validation performed exclusively on sparse sEMG (DB1); applicability to high-density sEMG or cross-subject calibration scenarios remains untested.
• Potential for performance improvement via channel attention mechanisms or dynamic kernel sizing.
• Need for research into online adaptation schemes to address electrode shift and muscle fatigue.
• Planned open-sourcing of training code to facilitate reproducibility and community-driven ablation studies.

XceptionTime combines the efficiency of depthwise separable convolutions, Inception-style multi-kernel modules, and window-agnostic pooling—augmented by μ-law normalization—to advance state-of-the-art sEMG-based gesture recognition (Rahimian et al., 2019).