# Look into the LITE in deep learning for time series classification

Ali Ismail-Fawaz, Maxime Devanne, Stefano Berretti, Jonathan Weber, Germain Forestier

<figure><img src="image_1.png" /></figure>

## To cite this version:

Ali Ismail-Fawaz, Maxime Devanne, Stefano Berretti, Jonathan Weber, Germain Forestier. Look into the LITE in deep learning for time series classification. International Journal of Data Science and Analytics, 2025, pp.1-21. 10.1007/s41060-024-00708-5. hal-04933061

HAL Id: hal-04933061

https://hal.science/hal-04933061v1

Submitted on 6 Feb 2025

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_2.png" /></figure>
# Look Into the LITE in Deep Learning for Time Series Classification

Ali Ismail-Fawaz <fnref n="1" /> · Maxime Devanne <fnref n="1" /> · · Stefano Berretti <fnref n="2" /> ·

Jonathan Weber <fnref n="1" /> · Germain Forestier <fnref n="1" />,<fnref n="3" />

**Abstract** Deep learning models have been shown to be a powerful solution for Time Series Classification (TSC). State-of-the-art architectures, while producing promising results on the UCR and the UEA archives, present a high number of trainable parameters. This can lead to long training with high CO2 emission, power consumption and possible increase in the number of FLoating-point Operation Per Second (FLOPS). In this paper, we present a new architecture for TSC, the **Light Inception with boosting technique (LITE)** with only 2.34% of the number of parameters of the state-of-the-art InceptionTime model, while preserving performance. This architecture, with only 9,814 trainable parameters due to the usage of DepthWise Separable Convolutions (DWSC), is boosted by three techniques: multiplexing, custom filters, and dilated convolution. The LITE architecture, trained on the UCR, is 2.78 times faster than InceptionTime and consumes 2.79 times less CO2 and power, while achieving an average accuracy of 84.62% compared to 84.91% with InceptionTime. To evaluate the performance of the proposed architecture on multivariate time series data, we adapt LITE to handle multivariate time series, we call this version LITEMV. To bring theory into application, we also conducted experiments using LITEMV on multivariate time series representing human rehabilitation movements, showing that LITEMV not only is the most efficient model but also the best performing for this application on the Kimore dataset, a skeleton based human rehabilitation exercises dataset. Moreover, to address the interpretability of LITEMV, we present a study using Class Activation Maps to understand the classification decision taken by the model during evaluation.

**Keywords** Time Series Classification, Deep Learning, Convolutional Neural Networks, DepthWise Separable Convolutions

## 1 Introduction

Time Series Classification (TSC) has been widely investigated by researchers in recent years. Some TSC tasks include the classification of surgical evaluation [29, 52, 18], action recognition of human motion [14, 32], cheat detection in video games [44], interpretability [58], Entomology [38], etc. Thanks to the availability of the UCR archive [9], and the UEA archive [2], the largest archives for univariate and multivariate TSC datasets, a significant amount of work has been done

<footnote n="1">¹IRIMAS, Université de Haute-Alsace, Mulhouse, France</footnote>

<footnote n="2">²MICC, University of Florence, Florence, Italy</footnote>

<footnote n="3">³DSAI, Monash University, Melbourne, Australia</footnote>
<figure><img src="image_3.png" /><figcaption>**Fig. 1** For each model, the accuracy on the FreezerSmallTrain dataset is presented on the y-axis and the number of FLoat-point Operations Per Second (FLOPS) is presented on the x-axis in log₁₀ scale. The diameter of the circles represents the number of trainable parameters of the model. The smallest model is LITE (ours) with only 10k trainable parameters and the lowest number of FLOPS (4 in log₁₀ scale); it also presents the highest accuracy score on the test set in this comparison.</figcaption></figure>

in this domain. Deep learning models have been proposed in the time series context for classification [30, 55, 31, 27, 42], clustering [33], averaging [53], representation learning [28, 60, 56], adversarial attacks [16, 43], etc. Even though deep learning approaches proven to be very powerful for TSC, they present a large amount of trainable parameters, which often leads to a long training time, inference time and storage usage.

For this reason, some works started to question the need of such a large complexity in deep learning models for TSC such as ROCKET and its variants [10, 11, 50]. Like for images, deep learning also presents a large complexity, which limits the usage of the models on small devices such as mobile phones and robots [23, 48]. Furthermore, Large Language Models (LLM) also shown to be very effective [6], and that their complexity can be decreased, while preserving performance [49].

In this paper, we address the methodology of reducing the complexity of deep learning models, while preserving the performance of the TSC task. We argue that a large complex model may not be necessary in order to perform well on the UCR archive. However, simply removing layers and or parameters to reduce complexity may not guarantee to preserve the performance. For this reason, the neural network architecture often requires additional techniques in order to balance between complexity and performance. In this work, we borrow existing techniques that have been efficiently used in state-of-the-art architectures on time series data. These techniques are multiplexing convolutions [31, 8], dilated convolutions [56], and custom filters [27]. By combining these three techniques with a modified version of a small non complex model, the Fully Convolution Network (FCN) [55],
we propose a new architecture, named Light Inception with boostTing tEchniques (LITE). The proposed model uses only 2.34% of the number of parameters of the Inception model, while being competitive with state-of-the-art architectures. For instance, Figure 1 shows that on the FreezermallTrain dataset, the classification accuracy of LITE is much higher than other approaches with way less trainable parameters. The reduction in number of parameters is made possible thanks to the usage of DepthWise Separable Convolutions (DWSC) [23]. The additional techniques used in this proposed architecture, multiplexing, dilated, and custom convolutions, have the advantage of only slightly increasing the number of parameters by about 1,000.

To position the proposed architecture among the state-of-the-art, we compared not only the accuracy but also the training time and number of parameters. A comparison of CO2 and Power consumption using CodeCarbon<fnref n="1" /> python library is also presented.

Assessing the utility of LITE in the case of both univariate and multivariate time series classification datasets is essential. For this reason, we propose two versions: LITE for univariate time series and LITEMV for multivariate time series. LITEMV differs from LITE only in the first layer, where we use DWSC instead of standard convolutions. This is not done in the case of the first layer of LITE, when the input is univariate because it would lead to learn only one filter, which is not suitable for the learning task (more details on DWSC are given in Section 3.1.2).

Moreover, to address a real world application, we assess the performance of LITE in the case of human rehabilitation exercises, represented as multivariate time series. For this task, the goal is to analyze the rehabilitation exercise performed by a patient and associate a score representing how good the exercise has been carried out. We rely on the usage of the Kimore dataset [7], a skeleton based human rehabilitation exercises dataset. Each sample of this dataset is a multivariate time series of skeleton poses changing through time. These skeleton poses are extracted using Kinect-v2 cameras [36]. In the original dataset, each skeleton sequence is associated with a continuous label for each sample representing a score between 0 and 100 given by an expert to evaluate the performance of the patient. Since this is a regression problem, we re-orient it to a classification task by classifying whether or not the patient performed the exercise correctly by setting a threshold to divide the scores (threshold score is 50). To understand the decision making process of our proposed deep learning model on this task, we also present a study of the interpretability of LITEMV using the Class Activation Map (CAM) [63, 55, 30].

The main contributions of this work are:

- The LITE model is presented as a new architecture for TSC, with only 2.34% of the number of parameters of the Inception model;

- An adaptation of LITE to handle multivariate data (LITEMV);

- Extensive experiments showing that LITE achieves state-of-the-art results on the UCR archive;

- Extensive experiments showing that LITEMV achieves promising results on some datasets of the UEA archive;

- A comparison based on the number of trainable parameters, number of FLOPS, training time, CO2 and Power consumption;

- A deeper analysis presented as an ablation study to show the impact of each technique added to boost the proposed model;

<footnote n="1">¹ https://codecarbon.io/</footnote>
- The application of LITEMV in a real application of evaluating human rehabilitation exercises with interpretability analysis using CAMs.

We note that this manuscript extends our previous work titled "LITE: Light Inception with booSTing Techniques for Time Series Classification" [25]. We have expanded our research to include the following enhancements:

- A comprehensive analysis on the significant impact of the number of LITE models in the LITE-Time ensemble;

- An extension of the LITE architecture to handle multivariate time series data;

- A detailed study on a real world application of human motion rehabilitation, complemented by explainability experiments;

In what follows, we present some related work in Section 2, discuss the details of our proposed architecture in Section 3, present some results compared to other approaches in Section 4, and conclude by drawing future work in Section 5.

## 2 Background and Related Work

Time Series Classification (TSC) is widely investigated in the literature. Some work addressed this problem using machine learning algorithms by comparing similarity metrics between the time series [3], decisions based on random forest algorithm [35], etc. The problem of most of those algorithms is that they require huge amount of CPU time to perform their calculations, and can not be parallelized on a cluster of GPUs. However, we acknowledge that libraries such as cuML [45] do exist, which allow for efficient execution of some machine learning workloads on GPUs. For these reasons, deep learning for TSC is being used in the recent years. Even though the accuracy and efficiency of deep learning often exceed those of traditional machine learning algorithms in many contexts, the number of parameters that need to be optimized can be significantly higher. In what follows, we first define the problem at hand, then we present some works that tackled the TSC problem using machine and deep learning techniques. Finally, we present some works that addressed the training time problem of deep learning models and the large number of parameters.

### 2.1 Definitions

- Let $\mathbf{x} = \{x_1, x_2, \dots, x_L\}$ denote a univariate *time series* of length *L*, consisting of a sequence of data points that are equally spaced in time and exhibit temporal dependencies;

- Let $\mathbf{X} = \{\mathbf{x}_1, \mathbf{x}_2, \dots, \mathbf{x}_M\}$ be a multivariate *time series* of *M* variables, where each variable is itself a univariate time series of length *L*.

- Let $\mathcal{D} = \{\mathbf{X}_i, y_i\}_{i=0}^{N-1}$ be a *dataset* of *N* multivariate *time series* $\mathbf{X}_i$ with their corresponding labels $y_i$.

The goal of this work is to construct an algorithm to learn how to correctly classify each input time series to its corresponding label.
## 2.2 Machine Learning for TSC

The basic approach to solve TSC tasks is by using the Nearest Neighbour (NN) algorithm. In order to use this algorithm, a specific similarity metric for time series data should be defined. In [3], the authors used the Dynamic Time Warping algorithm (DTW) to define a similarity metric for the NN algorithm. However, this algorithm does not have the ability to extract features from the input samples. The work in [61] also used the same algorithm but with an upgraded version of DTW called shapeDTW that aligns a local neighborhood around each point. The main limitation of the DTW algorithm and its variants is the time complexity, which is a function of the time series length, i.e., $O(L^2)$.

## 2.3 Deep Learning for TSC

In this section, we present the work done on TSC using deep learning approaches. The simplest architecture is the Multi Layer Perceptron (MLP) proposed in [55] that uses fully connected layers and dropout operations. This architecture is limited given the fact that it ignores the temporal dependency in a time series. The Fully Convolution Network (FCN) was also proposed in [55] that uses 1D convolution operations. In this model, the backpropagation algorithm finds the best filters to extract features from the time series, and correctly classifies the samples. In this model, convolutions account for temporal dependencies in time series data, and they are also independent of the input time series length. The authors in [55] also proposed the ResNet model, which uses the residual connections [21] to solve the vanishing gradient problem. A comparative study in [30] shows that using convolutions, especially ResNet, outperforms other models that use multi-scale transformation or pooling layers with convolutions [8,62]. ResNet and FCN use Batch Normalization and ReLU activation instead of pooling operations after each convolution layer to avoid overfitting. The state-of-the-art model in deep learning for TSC on the UCR archive [9] is InceptionTime [31], where the authors adapted the original Inception model on images for time series data. InceptionTime has the ability to detect multiple patterns of different length given to the multiplexing technique. This technique comes down to learning multiple convolution layers on the same input but with different characteristics. It is important to note that InceptionTime is an ensemble of five Inception models each trained separately.

While FCN, ResNet have also been evaluated for multivariate data, some additional deep learning models have been proposed to address the task of TSC in the case of multivariate data [47]. More recently, the Disjoint-CNN architecture [20], considered a new methodology for applying convolutions on multivariate time series that separates the temporal and spatial patterns extraction into two steps. The reference deep learning model for multivariate TSC on the UEA archive [2] is ConvTran [19], a Transformer based architecture. ConvTran uses a Disjoint-CNN based encoder followed by self-attention layers [54] with novel absolute and relative positional encoders.

Recurrent Neural Networks (RNNs), including their variants LSTM and GRU, have been investigated for Time Series Classification (TSC) [51,30]. While these models excel in sequential data processing, they often fail to perform optimally in TSC scenarios due to their design, which does not favor the discriminative identification of complex patterns across time series. This inherent limitation makes them less suited for tasks where precise pattern recognition in time series data is crucial.

Transfer learning and few-shot learning techniques [15,26] can be employed to reduce the training time for models like Inception by leveraging pre-trained networks. While these approaches decrease the duration of training significantly, they do not alter the model's complexity or reduce the number of parameters, which remains a consideration for inference tasks.
## 2.4 Reducing Model Complexity

While deep learning for Time Series Classification (TSC) has proven effective, it faces challenges, such as the extensive number of parameters requiring optimization which can prolong training time. An alternative approach introduced by [10] is ROCKET, which utilizes convolution operations but differs significantly from typical deep learning methods like InceptionTime [31]. Unlike traditional methods that learn filters through backpropagation, ROCKET employs a strategy of generating a large set (10,000) of 1D convolution filters randomly following a Gaussian distribution. These filters vary in length, bias value, padding, and dilation rate, and are not learned but are fixed upon initialization. Each convolution output is then processed to extract two features: the Proportion of Positive Values (PPV) and the maximum value. This results in a substantial feature vector, creating 20,000 features per series, which are used to train a Ridge classifier. Studies on the UCR archive [9] indicate no statistical significant difference in accuracy between InceptionTime and ROCKET, yet ROCKET offers a substantial advantage in terms of both training and inference speed.

Some adaptations of ROCKET were proposed in order to boost its performance even more such as MiniROCKET [11] and MultiROCKET [50]. Knowledge distillation [22] was also approached for the TSC model called FCN [1]. In this study, the authors proposed a smaller variant of FCN with a lower number of convolution layers and filters to learn.

Furthermore, the work in [27] proposed to hand-craft some custom convolution filters instead of randomly generate them. Those hand-crafted filters are constructed in a way to get activated on increasing and decreasing intervals as well as peaks in the time series. By using these filters, the authors were able to construct a Hybrid FCN (H-FCN). Results on the UCR archive shown that H-FCN is statistically significantly better than FCN and is competitive with InceptionTime. The H-FCN model uses the custom filters in parallel to the learned filters in the first layer.

Some work to optimize the complexity of large models were proposed in Computer Vision as well. For instance, the authors in [23] proposed the usage of DWSC instead of standard ones.

The MobileNet architecture as proposed in [23] proven to be very competitive with state-of-the-art models on ImageNet [13] with way less complexity.

In Natural Language Processing, some works proposed the usage of Small Language Models (SLM) as a one-shot learning approach [49]. The authors showed that with way less parameters than GPT-3 [6], their model can have no significant difference in performance.

# 3 Proposed approach

## 3.1 Convolutions for TSC

Multiple Convolution Neural Networks (CNNs) were proposed for the task of TSC and they all proved how they outperform other methods. The Fully Convolution Network (FCN) is a simple three layered network, where each layer is composed of 1D convolutions followed by a batch normalization and a ReLU activation function. As FCN is only composed of simple 1D convolution layers, its performance generally lags behind more advanced architectures using residual connections (ResNet) or Inception modules (InceptionTime). In this paper, we present an adaptation of the FCN architecture that only has 2.34% of the number of parameters of the Inception model. Given this significant drop in the number of parameters, boosting techniques are used in order to preserve the performance of Inception.

First, we discuss about two ways of applying convolutions with less number of parameters, while preserving the performance. The first approach uses standard convolutions with BottleNecks (BN), and the second uses DWSC.
### 3.1.1 Standard Convolutions with BottleNecks

Many approaches that use CNN based architectures suffer from the problem of high number of parameters such as ResNet [55]. For this reason, the authors of InceptionTime [31] proposed to use a BottleNeck operation in order to reduce the number of parameters. This BottleNeck operation is made of 1D convolutions with a unit kernel size.

The following example shows the impact of this operation on reducing the number of parameters. Suppose at a depth d in the network, the input number of channels is $C_{in}$. The following convolution layer of depth d+1 projects the input into a new space with a number of channels $C_{out}$ using a kernel of size k. On the one hand, without a BottleNeck operation, the number of learned parameters is $C_{in} * C_{out} * k$. On the other hand, with a BottleNeck operation that uses $C_{bn}$ filters of size 1, the number of learned parameters is $C_{in} * C_{bn} * 1 + C_{bn} * C_{out} * k$. This operation reduces the number of parameters if and only if the following inequality is true:

$$C_{in} * C_{bn} + C_{bn} * C_{out} * k < C_{in} * C_{out} * k, \quad (1)$$

which indicates that the condition on the BottleNeck operation is:

$$C_{bn} < \frac{C_{in} * C_{out} * k}{C_{in} + C_{out} * k}. \quad (2)$$

The goal of the BottleNeck operation is to learn the same number of filters in the output channels ($C_{out}$), while reducing, at the same time, the intermediate learned filters between the input and output channels ($C_{in} * C_{out}$).

### 3.1.2 DepthWise Separable Convolution DWSC

DWSC can be divided into two phases: DepthWise convolution (Phase 1), and PointWise convolution (Phase 2). A visual representation of the DWSC operation is presented in Figure 2.

In standard convolutions, if the input sample of length L has $C_{in}$ channels and the desired output is a space with $C_{out}$ channels using a kernel of size k, then the number of learned parameters is $C_{in} * C_{out} * k$. The number of multiplications is $L * C_{out} * C_{in} * k$. This assumes, as with other parts of this section, that the convolution layer uses “same” padding, thereby preserving the length from the input series to the output.

**DepthWise convolution** In this phase, if the convolution is done using a kernel of size k, then the number of learned filters is $C_{in}$, and the output number of channels will be $C_{in}$ (such as the input). In other words, for each dimension of the input time series, one filter is learned.

**PointWise convolution** This phase projects the output of the DepthWise convolution into a space with a desired number of channels $C_{out}$. This is done by applying a standard convolution with $C_{out}$ filters of kernel size 1 (a BottleNeck).

Equation 3 below presents the overall formulation of a DWSC layer applied on an input multi-variate time series $\mathbf{X} = \{\mathbf{x}_1, \mathbf{x}_2, \dots, \mathbf{x}_M\}$ with M variables of length L, with $C_{out}$ as a target output dimension using a kernel size of length k.

$$\mathbf{O} = \text{concat}(\{\sum_{m=1}^{M} \text{concat}(\{\mathbf{x}_m * \mathbf{w}_m\}_{m=1}^{M})^m . w_{m,j}\}_{j=1}^{C_{out}}) \quad (3)$$
<figure><img src="image_4.png" /><figcaption>**Fig. 2** DWSC for time series represented in its two phases: (1) DepthWise convolution (purple block), and (2) PointWise convolution (blue block).</figcaption></figure>

where $\mathbf{w}_m$ is the $m^{th}$ convolution filter applied in phase 1 (DepthWise convolution), $concat(\cdot)$ is the concatenation operation over the spatial dimension, $*$ is the one dimensional convolution operation and $w_{m,j}$ is one trainable scalar of phase 2 (PointWise convolution) where $m \in [1, M]$ and $j \in [1, C_{out}]$, making the output of the convolution $\mathbf{O}$ a multivariate time series of $C_{out}$ dimensions of length $L$ assuming a padding “same”.

Hence, by combining these two phases, the number of learned parameters in a DWSC becomes $C_{in} * k + C_{in} * C_{out}$.
The following calculation finds the condition that the DWSC have less parameters to learn compared to the standard one:

$$
\begin{align*}
\underbrace{C_{in} * C_{out} * k}_{\text{standard Conv}} &> \underbrace{C_{in} * k + C_{in} * C_{out}}_{\text{separable Conv}} \\
C_{in} * C_{out} * k &> C_{in} * (k + C_{out}) \\
C_{out} * k &> k + C_{out} \tag{4} \\
k * (C_{out} - 1) &> C_{out} \\
k &> \frac{C_{out}}{C_{out} - 1} \xrightarrow{C_{out} \to \infty} \boxed{k > 1}.
\end{align*}
$$

This means that if the number of desired output channels is high enough (if $C_{out} \ge 3$ the previous equation holds), then DWSC have less parameters to learn compared to the standard convolutions.

The number of multiplications performed in the DWSC is $C_{in} * L * k + C_{in} * C_{out} * L * 1$. The following calculation finds the second condition for when DWSC have less multiplications to perform compared to standard convolutions:

$$
\begin{align*}
\underbrace{C_{in} * C_{out} * L * k}_{\text{standard convs}} &> \underbrace{C_{in} * L * k + C_{in} * C_{out} * L * 1}_{\text{separable convs}} \\
C_{in} * C_{out} * L * k &> C_{in} * L * (k + C_{out}) \\
C_{out} * k &> k + C_{out} \tag{5} \\
k(C_{out} - 1) &> C_{out} \\
k &> \frac{C_{out}}{C_{out} - 1} \xrightarrow{C_{out} \to \infty} \boxed{k > 1}.
\end{align*}
$$

This concludes that DWSC have less parameters to learn with less number of multiplications to perform compared to standard convolutions. In this work, we present a comparison between the usage of DWSC or standard ones + BottleNecks. Our results demonstrate that with the techniques added to boost DWSC, we can maintain performance, while significantly reducing the number of parameters to optimize.

After defining two techniques to use convolutions in a more optimized way concerning number of parameters and multiplications, some other techniques should be defined as well. These techniques aim to minimize the impact of parameters reduction in convolutions operations explained above.

3.2 Boosting Techniques

The following techniques are borrowed from the literature.

*Multiplexing* Multiplex convolution was proposed in the architecture of Inception [31]. Its main idea is to learn in parallel different convolution layers of different kernel size. A multiplexing example is shown in Figure 3.

*Dilation* Dilated convolutions were not very explored for deep supervised learning on TSC when evaluating on the UCR archive [9] but they were used in self-supervised models showing to be very effective [56]. Additionally, outside the score of the UCR archive [9], some research work have addressed the task of deep supervised learning on TSC using dilated convolutions [46, 59, 4]. Dilation
<figure><img src="image_5.png" /><figcaption>**Fig. 3** Multiplexing one dimensional convolution on the input time series (in blue) using filters (in **green**) with three different kernel sizes, respectively, 3, 5, and 7. The output of the convolutions (in **red**) is different for each filter.</figcaption></figure>

in convolutions filters defines the number of empty cells in the kernel. Suppose a kernel of length 3 has the following parameters $k = [k_0, k_1, k_2]$, a dilation of rate 2 will produce the following kernel $k = [k_0, skip, k_1, skip, k_2]$. The *skip* parameter indicates that the convolution layer will not use the values of the input aligned with this index of the kernel. A visualization of the dilation effect on convolution can be seen in Figure 4. Dilation will help increasing the receptive field of a model without having to add deeper layers because the dilated kernel will find the deeper combinations in the same layer.

*Custom Filters* Custom filters were proposed in [27]. The authors hand-crafted some kernels in order to detect specific patterns in the input time series. These filters were then added to Inception and results on the UCR archive have shown that such filters can help with the generalization and
<figure><img src="image_6.png" /><figcaption>**Fig. 4** One dimensional convolution performed w/o dilation on the left (rate=1), and with dilation on the right (rate=2).</figcaption></figure>

boost the performance. This is due to the fact that these filters are generic and fixed (not learned). This allows the model to focus on learning new patterns harder to detect.

## 3.3 Proposed architecture

### 3.3.1 Light Inception with boosting techniques (LITE)

In our proposed architecture, we reduce the number of parameters, while preserving performance. This is obtained by using DWSC and the previously explained boosting techniques. First, custom filters are used in the first layer parallel to the first layer. Second, in this first layer, multiplexing convolution is used in order to detect different patterns of different characteristics (three parallel convolution layers). Third, the second and third layer present the usage of dilation in their kernels. It is important to notice that for the first layer, standard convolutions are used instead of DWSC. This is due to the fact that the input time series is univariate and DWSC will learn only one filter. A summary of the architecture is given in Figure 5.

### 3.3.2 LITEMV: Adapting LITE for Multivariate Time Series Data

The first layer of the LITE architecture uses the standard convolution in the case of univariate data. This is due to the fact that using DepthWise Separable Convolutions in the first layer means the model would only learn one filter and then re-scale the output with one learned value. For this reason we kept the usage of Standard Convolutions in the first layer. However, in the case of multivariate data, the model will learn a filter per channel and then learn how to combine in the
<figure><img src="image_7.png" /><figcaption>**Fig. 5** The proposed LITE architecture that uses multiplexing convolutions in the first layer (three convolution blocks in **orange**) with custom filters (in **green**). The second and third layer are composed of DWSC (in **beige**). The last layer is followed by a Global Average Pooling (GAP) on the time axis and finished by a classification Fully Connected layer to approximate the class distribution.</figcaption></figure>

PointWise Convolution step. A second information that is important to note is that the custom filters in the first layer of LITE are basically Standard Convolutions. This means in the case of multivariate input, the custom filter will be applied to each channel independently and the output are summed. This is done for each of the used custom filters. This can be an issue in the case of multivariate input given we suppose an equal importance per custom filter for all channels when summing the outputs. In the multivariate version of LITE, we instead concatenate the outputs of all custom filters operations on all channels. We refer in the rest of this work to the multivariate version of LITE as LITEMV.

### 3.3.3 Ensemble

Ensemble learning is a technique of combining the prediction of multiple models in order to reduce the variance, and it has been shown to be very effective in the literature [16, 32, 39, 40]. Applying an ensemble of multiple classification models is equivalent to find the average predicted distribution of all the models. This average distribution is finally used for choosing the predicted class. This motivated us to build an ensemble of multiple LITE models to form LITETime and LITEMVTime (by adding the suffix *Time* following [31]). Moreover, the usage of an ensemble in the case of LITE is also motivated by its small architecture and the fact that it can boost less complex architectures even more.

## 4 Experimental Evaluation

### 4.1 Datasets

The UCR archive [9] is the largest directory for the TSC problem. It is publicly available [9]. The archive contains 128 datasets of univariate TSC tasks. Some tasks involves Electrocardiography (ECG) time series data and some are observations of Sensors, etc. To evaluate the performance
<table><caption>**Table 1** Comparison between the proposed methods with FCN, ResNet and Inception without ensemble.</caption><thead><tr><th>Models</th><th>Number of parameters</th><th>FLOPS</th><th>Training Time</th><th>Testing Time</th><th>CO2<sub>eq</sub></th><th>Energy</th></tr></thead><tbody><tr><td>Inception</td><td>420,192</td><td>424,414</td><td>145,267 seconds<br>1.68 days</td><td>81 seconds<br>0.0009 days</td><td>0.2928 g</td><td>0.6886 kWh</td></tr><tr><td>ResNet</td><td>504,000</td><td>507,818</td><td>165,089 seconds<br>1.91 days</td><td>62 seconds<br>0.0007 days</td><td>0.3101 g</td><td>0.7303 kWh</td></tr><tr><td>FCN</td><td>264,704</td><td>266,850</td><td>149,821 seconds<br>1.73 days</td><td>27 seconds<br>0.00031 days</td><td>0.2623 g</td><td>0.6176 kWh</td></tr><tr><td>LITE</td><td>9,814</td><td>10,632</td><td>53,567 seconds<br>0.62 days</td><td>44 seconds<br>0.0005 days</td><td>0.1048 g</td><td>0.2468 kWh</td></tr></tbody></table>

of the proposed architecture on more datasets, we detail in Section 4.5 some experiments on multivariate time series data. The usage of multivariate data is a bit different given the uniqueness of this data of having multiple variables changing through time. We rely on the UEA Multivariate Time Series Classification (MTSC) archive [2]. This archive consists of 30 different datasets ranging from medical data recording ECG signals to speech recognition. The number of channels in this archive range from 2 to 1345.

Each dataset is split into a training and a testing set. The labels are available for all the samples. In order to train the model on a normalized dataset, we apply z-normalization over all the samples independently. This normalization technique reduces the time series samples to a zero mean and unit variance sequence.

## 4.2 Implementation Details

Our results were obtained on the UCR archive using a GTX 1080 GPU with 8GB of VRAM. In the experiments, we accounted for the training time, inference time (testing time), CO2 and Power consumption. The model used for testing is the best model during training, chosen by monitoring the training loss. The Adam optimizer was used with a Reduce on Plateau learning rate decay method by monitoring the training loss. For the Adam optimizer we used the default set up of the Tensorflow Python model. The model is trained with a batch size of 64 for 1500 epochs.

For the hyper-parameters of the LITE architecture presented in Figure 5, the following setup was used: $N_i = 6$, variations in kernel sizes = [2, 4, 8, 16, 32, 64]; $N_d = 6$, variations in kernel sizes = [2, 4, 8, 16, 32, 64]; $N_p = 5$, variations in kernel sizes = [6, 12, 24, 48, 96]; $N = 32$; $K = 40$; $D0 = 1$ in order to start with no dilation and increase with depth ($D1 = 2$ and $D2 = 4$). The same hyper-parameters were used in the case of LITEMV. The source code is publicly available at https://github.com/MSD-IRIMAS/LITE.

## 4.3 Results and Discussion

Below, we provide the comprehensive set of experimental results acquired during the course of this study. First, we present an efficiency comparison between LITE and other architectures in the literature. This study is done over the case of univariate data only because in the case of multivariate data the study will depend on each dataset and its number of channels. Second, we present an ablation study to make sure that LITE utilizes all of its boosting techniques during training. Third, we present the performance using the accuracy metric on both the UCR and UEA
<figure><img src="image_8.png" /><figcaption>**Fig. 6** One-vs-One comparison between LITE with three different models: FCN, ResNet and Inception over the 128 datasets of the UCR archive.</figcaption></figure>

archives. Finally, we evaluate the usage of LITEMVTime in a real world application for human motion rehabilitation on the Kimore dataset.

### 4.3.1 Number of Parameters, FLOPS Training Time, Testing time, CO2 and Power Consumption

Table 1 summarizes the number of parameters, the number of FLoating-point Operations Per Second (FLOPS), training time, inference time, CO2 and Power consumption over the 128 datasets of the UCR archive. We show the number of trainable parameters of the architecture without the last classification Fully Connected layer because it depends on each dataset (number of classes). The rest of the information is summed over the 128 datasets of the UCR archive and averaged over five different runs.

First, the table shows that the smallest model in terms of number of parameters is the LITE with 9,814 parameters. This is mainly due to the usage of DWSC instead of standard ones. Compared to FCN ResNet and Inception, LITE has only 3.7% 1.95% and 2.34% of their number of parameters, respectively. Second, the fastest model in the training phase is LITE, with a training time of 0.62 days. LITE is 2.79, 3.08 and 2.71 time faster than FCN, ResNet and Inception, respectively. Third, LITE is the model that consumes the smallest amount of CO2 and Power, 0.1048 grams and 0.2468 Watts, respectively. Compared to the other approaches, LITE presents the fastest and most ecologic model for TSC compared to FCN, ResNet and Inception. We believe, given the factors explained above, that LITE can be used for the deployment of deep learning for TSC in small machine such as mobile phones. As shown in Table 1, the LITE model not only has the smallest number of parameters among the evaluated models but also has the second fastest inference time, making it well-suited for environments where model size and speed are crucial.

Although DTW is a relevant technique in time series analysis, it was not included in our comparative efficiency analysis due to its inability to be parallelized on GPUs, a feature that our proposed deep learning approaches exploit to achieve scalability and speed. Additionally, ROCKET was excluded from our efficiency comparative analysis because it is primarily implemented for multi-threaded CPU use, not GPU acceleration, which differs from the hardware focus of our study.

### 4.3.2 Accuracy Performance on the UCR Archive

In what follows, a one-vs-one comparison is presented between the models in order to show that LITE can preserve the performance of the more complex architectures. This one-vs-one comparison comes down to a Win/Tie/Loss count on the 128 datasets of the UCR archive between two classifiers. This comparison is visualized in Figures 6 and 7. Each point in these plots represents one
<figure><img src="image_9.png" /><figcaption>**Fig. 7** One-vs-One comparison between LITETime with two different models: InceptionTime and ROCKET over the 128 datasets of the UCR archive.</figcaption></figure>

<table><caption>**Table 2** Datasets where Inception beats LITE by more than 10% of accuracy.</caption><thead><tr><th>Dataset Name<br>where Inception<br>is better than LITE</th><th>Difference in<br>Accuracy (%)</th><th>Series Length</th><th>Number of<br>Samples</th></tr></thead><tbody><tr><td>EthanolLevel</td><td>11.32</td><td>1751</td><td>504</td></tr><tr><td>OliveOil</td><td>15.34</td><td>570</td><td>30</td></tr><tr><td>PigAirwayPressure</td><td>16.64</td><td>2000</td><td>104</td></tr><tr><td>ShapeletSim</td><td>21.44</td><td>500</td><td>20</td></tr></tbody></table>

dataset of the UCR archive. The *x*-axis contains the accuracy value on the test set using classifier-*x* and the *y*-axis the ones using classifier-*y*.

In order to evaluate the significance of the Win/Tie/Loss comparison, a statistical Wilcoxon Signed Rank Test [57] is used. This test will return a statistical value, the P-Value, representing how significant the difference is between the two classifiers. If the P-Value is low, this would mean that the difference in performance between the two classifiers is statistically significant. If the last condition is not true, it means that there are not enough examples (datasets) to find a statistical significant difference between the classifiers. This Wilcoxon test needs a P-Value threshold, usually in the literature a 0.05 (or 5%) threshold is used.

On the one hand, the results presented in Figure 6 show that LITE beats FCN significantly (low *P*-Value), and is statistically not significant than ResNet (high *P*-Value). The results compared to ResNet are impressive given the small complexity of LITE (almost 1.95% of ResNet's number of parameters). On the other hand, the comparison shows that LITE still is not significantly close to Inception. To study more the reason why LITE performs not as good as Inception with a large margin (more than 10%), we presented some characteristics of those datasets in Table 2. This table shows that some of the datasets have either long time series or small training set. Firstly, this indicates that Inception is better than LITE on long time series given its large receptive field (deeper architecture). Secondly, this demonstrates that the Inception model generally exhibits stronger generalization capabilities, particularly when the dataset has a smaller training set.
Given that Inception still beats LITE, an ensemble comparison shows the real performance of the proposed architecture. This is due to the fact that LITE has way less parameters (2.34% of Inception's number of parameters), which can make it sensitive to a higher variance when training with different initialization. Applying an ensemble removes this variance as explained before.

The comparison between LITETime with InceptionTime and ROCKET is presented in Figure 7. This comparison shows that, given the 128 datasets of the UCR archive, there are not enough datasets to find a statistical significance in the difference of performance with InceptionTime and ROCKET. We included ROCKET in the ensemble comparison with LITETime because the motivation in ROCKET is to replace the ensemble technique by using random filters instead of learning them starting with different initialization.

Those last results suggest that in order to get a good performance on the UCR archive, a large complex architecture with a high number of parameters is not always needed.

For a multi-classifier comparison, the average rank of each model is shown in a Critical Difference Diagram [12] (CD Diagram) based on the ranking classifiers given the average rank over multiple datasets, the two tailed Wilcoxon Signed-Rank Test with the Holm multiple test correction [5]. To generate the CD Diagram, we used the publicly available code https://github.com/hfawaz/cd-diagram. This diagram also presents connections between classifiers, when the difference in performance is not statistically different following the Wilcoxon Signed Rank Test. A CD Diagram is presented in Figure 8 and shows that LITETime comes 3rd on the average rank between ROCKET and InceptionTime. The diagram also shows that FCN performs statistically significantly worse than LITE on the average rank. Furthermore, on the UCR archive, no statistical significance can be observed between ResNet and LITE. This last comparison shows the real impact of this work where LITE has almost 1.95% (Table 1) of ResNet's number of parameters. These conducted results show that on a large amount of cases, there is no need for a complex model with high number of parameters to achieve good performance.

<figure><img src="image_10.png" /><figcaption>**Fig. 8** A Critical Difference Diagram (CD Diagram) showing the average rank of each classifier over the 128 datasets of the UCR archive with the significance in difference of performance.</figcaption></figure>

Furthermore, a new Multi-Comparison Matrix (MCM) evaluation tool was proposed that is stable to the variation of the addition and removal of classifiers [24]. The MCM is presented in Figures 9 and 10 to compare LITE and LITETime, respectively, to other approaches in the literature. The MCM uses the average accuracy on the UCR as an ordering metric instead of the average rank. As presented in the MCMs, LITE and LITETime perform better than FCN and ResNet on the average accuracy and is closer to the performance of InceptionTime, which is not significantly different than LITETime (high p-value). MCM has an advantage over the usage of the CD Diagram of being stable with the addition and removal of classifiers, given that the average performance would not change in this scenario unlike the average rank. Another advantage is not using a multiple test correction for the P-Value significance test.
<figure><img src="image_11.png" /><figcaption>**Fig. 9** The Multi-Comparison Matrix applied to show the performance of LITE compared to other approaches.</figcaption></figure>

<figure><img src="image_12.png" /><figcaption>**Fig. 10** The Multi-Comparison Matrix applied to show the performance of LITETime compared to other approaches.</figcaption></figure>

<figure><img src="image_13.png" /><figcaption>**Fig. 11** A collection of four Pareto plots showcasing the average accuracy of the four models ResNet [55], Inception [31], FCN [55] and ours LITE, over the UCR archive datasets [9] in function of the number of parameters, number of flops, training time (in days) and inference time (in days).</figcaption></figure>

As depicted in the MCM in Figure 10, LITETime outperforms Inception with statistical significance in terms of accuracy. Regarding latency, although a single LITE model operates at approximately half the inference time of Inception, the combined inference time of the LITETime ensemble, which includes five LITE models, is about 2.5 times that of Inception. However, it is crucial to note that the ensemble's overall complexity in terms of the number of parameters is significantly reduced—eight times smaller than Inception. This substantial reduction in model complexity, coupled with the potential for parallelizing these models, suggests that improvements in parallel processing could effectively diminish the apparent latency disadvantage, offering a practical solution for scenarios where model efficiency and reduced hardware demand are critical.
<figure><img src="image_14.png" /><figcaption>**Fig. 12** The Heat Map shows the one-vs-one comparison between the Striped-LITE and the three variants: (1) Add-Custom-Filters, (2) Add-Multiplexing-Convolution and (3) Add-Dilated-Convolution. The colors of the Heat Map follow the value of the first line in each cell. This value is the difference between the value of the first line (average accuracy when winning/losing). The second line represents the Win/Tie/Loss count between the models in question (wins for the column model). The last line is the statistical *P*-Value between the two classifier using the Wilcoxon Signed Rank Test.</figcaption></figure>

In addition to Table 1, Figure 11 presents similar metrics, including a collection of Pareto plots comparing the average performance of LITE and three comoetitotrs in function of number of parameters, number of FLOPS, training time and infernce time. The plot illustrates that LITE performs as good as state-of-the-art models, such as Inception with a difference in average accuracy of only 0.89%, while being 42 times smaller than Inception, having 40 times less FLOPS, and being 2.7 and 1.8 times faster in terms of training and inference time respectively.

## 4.4 Ablation Study - LITE

### 4.4.1 Impact of Additional Techniques

The proposed LITE architecture, uses multiple techniques in order to improve the performance. In order to show the impact of each technique on the proposed architecture, an ablation study is presented in this section. First, the LITE is stripped down from the three used techniques: dilation, multiplexing and custom filters. Second, given that for the multiplexing convolutions performed in the first layer there are a total of three layers with *n* filters, the Striped-LITE learns a total of 3*n* filters for the first layer. The rest of the architecture is the same using DWSC without dilation. We then add each boosting technique separately on the stripped LITE model and evaluate its performance. The results of this ablation study are visualized in Figure 12 in the form of a Heat Map. Each cell of the Heat Map contains the Win Tie Loss count when evaluating the test accuracy on the UCR archive. The addition of the *P*-Value statistics is presented in each cell in order to assess the significance in difference of performance. The *P*-Value is emphasized in **bold** when it is lower than the specified threshold (0.05). The colors of the Heat Map represent the difference in the average accuracy.

Results show that adding custom filters in the first layer as well as using multiplexing convolution in the first layer significantly boosts the performance. The colors of the Heat Map indicates that adding the custom filters has also a positive impact on the average accuracy though it can add some parameters. This is not the case for the multiplexing convolutions. We believe that this small average impact (0.34% overall) is not as important as the positive one. This is due to the fact that multiplexing reduces the number of parameters and wins over the majority of the datasets
significantly. The addition of the dilated convolution is shown to not have a statistical significance on the performance (*P*-Value > 0.05). However, the average difference in accuracy shows that most of the times, using the dilated convolutions can improve the results. Given that dilation does not add more parameters and on average it boosts the performance, we keep it in the LITE architecture. This is due to the fact that dilation increases the receptive field, so for large datasets this can be a boosting feature. The reason why sometimes Dilation can have a negative effect is because some of the datasets in the UCR archive do not require a large receptive field. Altogether, the LITE model (with the boosting techniques) will have less parameters compared to the striped LITE, while preserving performance compared to state-of-the-art models. The decrease in number of parameters when using all the boosting techniques together comes from the fact that multiplexing removes more parameters than the custom filters adds. Lastly, Figure 12 shows the average rank of the models, such as in the CD Diagram explained in Section 4.3.2. The average rank of the Add-Custom-Filters is the lowest, while the Striped-LITE has the highest rank. Therefore, the worst model between the four presented in the Heat Map is the LITE without any boosting techniques.

### 4.4.2 Impact of DWSC

To show the effect of DWSC as well, we replace them by standard convolutions followed by a BottleNeck. To get a non-noisy comparison, we used ensembles. Note that the usage of the ensemble technique is necessary in this case given that by removing the DWSC, the difference in number of parameters becomes very high (LITE has almost 11% of the compared model's number of parameters (the compared model has around 85,000 parameters). In Figure 13, the one-vs-one comparison between LITETime and LITETime with Standard Convolutions is presented. Results show that the usage of DWSC does not have an effect on the performance because the *P*-Value is high 0.4556. This means that the difference in performance is not statistically significantly different with less parameters mainly due to the usage of the DWSC.

<figure><img src="image_15.png" /><figcaption>**Fig. 13** One-vs-one comparison between LITETime and LITETime with Standard convolutions over the 128 datasets of the UCR archive.</figcaption></figure>
<figure><img src="image_16.png" /><figcaption>**Fig. 14** A Crtical Difference diagram showcasing the comparison of performance of LITETime when more or less LITE models are used in the ensemble.</figcaption></figure>

### 4.4.3 Number of LITE Models in the Ensemble

Given that LITETime is an ensemble of multiple LITE models, we stick to using five LITE models in LITETime in order to be fairly comparable to InceptionTime (ensemble of five Inception models). It has been experimentally shown in [31] that no significant difference of performance can be found on the UCR archive when more than five Inception models are considered in the ensemble InceptionTime. However, in the case of LITE, given its small architecture, its more bound to produce more variance and be less robust than Inception. For this reason, we believe that the number of LITE models can be higher in the ensemble LITETime. To experimentally prove our hypothesis, we trained ten different LITE models on all the UCR archive. Ensembles of 1, 2, 3, ..., 10 are constructed by averaging over all possible ensemble combinations. For instance, if the goal is to construct LITETime-3 (ensemble of three LITE models), we constructed the ensemble of all possible combinations of three LITE models from the pool of ten trained models. We present the results on the CD diagram in Figure 14.

It can be seen from Figure 14 that in the case of LITE, LITETime-5 (ensemble of five LITE models) is not the limit that we can achieve, instead it is LITETime-7. This is due to the fact that LITE is almost 42 times smaller than Inception. The ability to achieve this comes with the advantage of enhancing accuracy whilst LITETime exhibits a considerably smaller complexity compared to InceptionTime. LITETime-5 with five models has almost 2.34% of InceptionTime's trainable parameters but LITETime-7 increases this percentage only to 3.27. This can be seen with an example on the Beef dataset of the UCR archive in Figure 15. In this figure, we plot how the number of models in the case of LITETime and InceptionTime changes the performance on unseen data.

### 4.5 Accuracy Performance on the UEA Archive

In Table 3, we present the accuracy performance of LITEMVTime, LITETime and five different competitors: ConvTran, InceptionTime, Disjoint-CNN, FCN and ResNet. The accuracies of all five competitors are reported from the ConvTran paper [19]. For the LITEMVTime model, we can see that when it wins over other models, a significant gap is observed between the accuracies. This can be clearly seen as well in the MCM plot of LITEMVTime with the rest of the models in Figure 16. It can be seen that LITEMVTime comes second on the average performance, outperforming Disjoint-CNN and InceptionTime. LITEMVTime still does not win on more than seven datasets compared to ConvTran, but looking deeper into Table 3, it can be seen that LITEMVTime can win with a large margin of accuracy. For instance, for the EigenWorms dataset, the highest accuracy is reported by ConvTran with a value of 59.34%, however LITEMVTime produces an accuracy of 93.89% and LITETime with an accuracy of 95.42%.

To study in more details the cases where LITEMVTime works better than ConvTran with a significant margin, we present in Figure 17 the difference in performance between these two models
<figure><img src="image_17.png" /><figcaption>**Fig. 15** A Comparison on the Beef dataset of the UCR archive between the ensemble of LITE and Inception models. The *x* axis represents the number of models used in each ensemble and the *y* axis the performance of the ensemble on the test set of the Beef dataset.</figcaption></figure>

<figure><img src="image_18.png" /><figcaption>**Fig. 16** A Multi-Comparison Matrix (MCM) showcasing the performance of LITEMVTime, InceptionTime, Disjoint-CNN and ConvTran on the 30 datasets of the UEA archive.</figcaption></figure>

in function of the training samples per class. This study is done to make sure if there are any common information about the cases where LITEMVTime works much better than ConvTran. From Figure 17, we can see the most significant differences in performance are in the case of three datasets: StandWalkJump, EigenWorms and EthanolConcentration. It can be seen that these datasets do not have the same range in the number of training examples. For instance, StandWalkJump is considered to have a small training set with 4 training examples per class and 12 training examples in total. However, the EthanolConcentration dataset has 66 training examples per class and 261 training samples in total.

Another approach to study the reason why these datasets would work better than ConvTran when using LITEMVTime is to dig into the number of dimensions, taking advantage that this is the case of multivariate time series data. In Figure 18, we present the same information as in Figure 17 but in function of the number of dimensions of the MTS datasets. It can be seen that the same three datasets have a small number of dimensions. It can be also seen that ConvTran always wins when the number of dimensions increases.

## 4.6 Experiments on Human Motion Rehabilitation

To assess the performance of LITEMVTime in a real life application, we consider the Human Rehabilitation domain. For this domain, the data is extracted from patients into the form of 3D skeleton based sequences. A human expert has to assess for each patient if they are doing a movement (rehabilitation exercise) correctly or not. This is a very important application and is highly correlated
<table><caption>**Table 3** Accuracy performance in % of LITEMVTime (LMVT), LITETime (LT), ConvTran (CT), InceptionTime (IT), Disjoint-CNN (D-CNN), FCN and ResNet on 30 datasets of the UEA archive. The datasets are ordered by their average number of training samples per class. The accuracy of the best model for each dataset is presented in bold and of the second best is underlined.</caption><thead><tr><th>Dataset</th><th>Train Size per Class</th><th>LMVT</th><th>LT</th><th>CT</th><th>IT</th><th>D-CNN</th><th>FCN</th><th>ResNet</th></tr></thead><tbody><tr><td>FaceDetection</td><td>2945</td><td>61.01</td><td>62.37</td><td><strong>67.22</strong></td><td>58.85</td><td>56.65</td><td>50.37</td><td>59.48</td></tr><tr><td>InsectWingbeat</td><td>2500</td><td>61.72</td><td>39.79</td><td><strong>71.32</strong></td><td>69.56</td><td>63.08</td><td>60.04</td><td>65.00</td></tr><tr><td>PenDigits</td><td>750</td><td><strong>98.86</strong></td><td>98.83</td><td>98.71</td><td>97.97</td><td>97.08</td><td>98.57</td><td>97.71</td></tr><tr><td>SpokenArabicDigits</td><td>660</td><td>98.59</td><td>98.77</td><td><strong>99.45</strong></td><td>98.72</td><td>98.59</td><td>98.36</td><td>98.32</td></tr><tr><td>LSST</td><td>176</td><td><strong>66.42</strong></td><td>62.85</td><td>61.56</td><td>44.56</td><td>55.59</td><td>56.16</td><td>57.25</td></tr><tr><td>FingerMovements</td><td>158</td><td><strong>56.00</strong></td><td>44.00</td><td><strong>56.00</strong></td><td><strong>56.00</strong></td><td>54.00</td><td>53.00</td><td>54.00</td></tr><tr><td>MotorImagery</td><td>139</td><td>53.00</td><td>51.00</td><td><strong>56.00</strong></td><td>53.00</td><td>49.00</td><td>55.00</td><td>52.00</td></tr><tr><td>SelfRegulationSCP1</td><td>134</td><td>73.04</td><td>75.09</td><td><strong>91.80</strong></td><td>86.34</td><td>88.39</td><td>78.16</td><td>83.62</td></tr><tr><td>Heartbeat</td><td>102</td><td>61.46</td><td>67.80</td><td><strong>78.53</strong></td><td>62.48</td><td>71.70</td><td>67.80</td><td>72.68</td></tr><tr><td>SelfRegulationSCP2</td><td>100</td><td>55.00</td><td>53.89</td><td><strong>58.33</strong></td><td>47.22</td><td>51.66</td><td>46.67</td><td>50.00</td></tr><tr><td>PhonemeSpectra</td><td>85</td><td>15.81</td><td>17.45</td><td><strong>30.62</strong></td><td>15.86</td><td>28.21</td><td>15.99</td><td>15.96</td></tr><tr><td>CharacterTrajectories</td><td>72</td><td><strong>99.58</strong></td><td>99.51</td><td>99.22</td><td>98.81</td><td>99.45</td><td>98.68</td><td>99.45</td></tr><tr><td>EthanolConcentration</td><td>66</td><td><strong>69.20</strong></td><td>67.30</td><td>36.12</td><td>34.89</td><td>27.75</td><td>32.32</td><td>31.55</td></tr><tr><td>HandMovementDirection</td><td>40</td><td>35.14</td><td>21.62</td><td>40.54</td><td>37.83</td><td><strong>54.05</strong></td><td>29.73</td><td>28.38</td></tr><tr><td>PEMS-SF</td><td>39</td><td>79.19</td><td>82.66</td><td>82.84</td><td><strong>89.01</strong></td><td><strong>89.01</strong></td><td>83.24</td><td>73.99</td></tr><tr><td>RacketSports</td><td>38</td><td>73.68</td><td>78.29</td><td><strong>86.18</strong></td><td>82.23</td><td>83.55</td><td>82.23</td><td>82.23</td></tr><tr><td>Epilepsy</td><td>35</td><td><strong>99.28</strong></td><td>98.55</td><td>98.55</td><td><strong>99.28</strong></td><td>88.98</td><td><strong>99.28</strong></td><td><strong>99.28</strong></td></tr><tr><td>JapaneseVowels</td><td>30</td><td>96.49</td><td>97.30</td><td><strong>98.91</strong></td><td>97.02</td><td>97.56</td><td>97.30</td><td>91.35</td></tr><tr><td>NATOPS</td><td>30</td><td>90.00</td><td>88.89</td><td><strong>94.44</strong></td><td>91.66</td><td>92.77</td><td>87.78</td><td>89.44</td></tr><tr><td>EigenWorms</td><td>26</td><td>93.89</td><td><strong>95.42</strong></td><td>59.34</td><td>52.67</td><td>59.34</td><td>41.98</td><td>41.98</td></tr><tr><td>UWaveGestureLibrary</td><td>15</td><td>84.68</td><td>85.00</td><td>89.06</td><td><strong>90.93</strong></td><td>89.06</td><td>85.00</td><td>85.00</td></tr><tr><td>Libras</td><td>12</td><td>89.44</td><td>87.78</td><td><strong>92.77</strong></td><td>87.22</td><td>85.77</td><td>85.00</td><td>83.89</td></tr><tr><td>ArticularyWordRecognition</td><td>11</td><td>97.33</td><td>97.67</td><td>98.33</td><td><strong>98.66</strong></td><td><strong>98.66</strong></td><td>98.00</td><td>98.00</td></tr><tr><td>BasicMotions</td><td>10</td><td><strong>100.0</strong></td><td>95.00</td><td><strong>100.0</strong></td><td><strong>100.0</strong></td><td><strong>100.0</strong></td><td><strong>100.0</strong></td><td><strong>100.0</strong></td></tr><tr><td>DuckDuckGeese</td><td>10</td><td>18.00</td><td>24.00</td><td><strong>62.00</strong></td><td>36.00</td><td>50.00</td><td>36.00</td><td>24.00</td></tr><tr><td>Cricket</td><td>9</td><td>98.61</td><td>97.22</td><td><strong>100.0</strong></td><td>98.61</td><td>97.72</td><td>93.06</td><td>97.22</td></tr><tr><td>Handwriting</td><td>6</td><td><strong>40.00</strong></td><td>36.82</td><td>37.52</td><td>30.11</td><td>23.72</td><td>37.60</td><td>18.00</td></tr><tr><td>ERing</td><td>6</td><td>84.44</td><td>89.63</td><td><strong>96.29</strong></td><td>92.96</td><td>91.11</td><td>90.37</td><td>92.96</td></tr><tr><td>AtrialFibrillation</td><td>5</td><td>13.33</td><td>06.67</td><td><strong>40.00</strong></td><td>20.00</td><td><strong>40.00</strong></td><td>33.33</td><td>33.33</td></tr><tr><td>StandWalkJump</td><td>4</td><td><strong>66.67</strong></td><td>60.00</td><td>33.33</td><td>40.00</td><td>33.33</td><td>40.00</td><td>40.00</td></tr><tr><td>Average</td><td>-</td><td>70.99</td><td>69.37</td><td><strong>73.83</strong></td><td>68.95</td><td>70.52</td><td>67.70</td><td>67.20</td></tr></tbody></table>

with this work given that this type of data can be regarded as Multivariate Time Series. For each sequence recorded, we have a specific number of joints in a three dimensional space. In other words, each sequence is a multivariate time series with $3 * J$ channels where $J$ is the number of human joints.

For this experiment, we used the Kimore dataset [7]. This dataset contains recorded sequences in the form of videos of patients performing rehabilitation exercises, which are then transformed into numerical MTS using kinect v2 [36]. This dataset contains both healthy and unhealthy subjects performing five different rehabilitation exercises. A human expert then assesses the quality of the performed exercise by providing a score between 0 and 100, from bad to good respectively. A visualization of the distribution of these scores for each exercise is presented in Figure 20 in the case of healthy and unhealthy subjects. It can be seen, for instance, that most cases of unhealthy subjects tend to have a low score and a high score in the case of healthy subjects. Given that this is a
<figure><img src="image_19.png" /><figcaption>**Fig. 17** A one-vs-one comparison between CongTran and LITEMVTime with respect to the average training size per class. Each point represents one dataset with its *x* coordinate being the average training size per class (in log scale) and its *y* coordinate being the difference between the accuracy of LITEMVTime and ConvTran. A positive value on the *y* axis indicates a win for LITEMVTime.</figcaption></figure>

<figure><img src="image_20.png" /><figcaption>**Fig. 18** A one-vs-one comparison between CongTran and LITEMVTime with respect to the number of channels in the input multivariate time series. Each point represents one dataset with its *x* coordinate being the number of channels (in log scale) and its *y* coordinate being the difference between the accuracy of LITEMVTime and ConvTran. A positive value on the *y* axis indicates a win for LITEMVTime.</figcaption></figure>

regression dataset, we re-orient the task to learn a deep learning model to evaluate the performance of a subject regardless of being healthy or not. Instead, the evaluation is done as following:

- if the subject's score is less than 50, the exercise is considered to be badly performed;

- if the subject's score is higher than 50, the exercise is considered to be performed well.

Some examples of the five exercises are presented in Figure 19.

Each recorded sequence has a different length, which should be fixed to one common length in order to use deep learning models. We resampled <fnref n="2" /> all the samples in the data into the average length, which is 748. The sequences contain 18 human joints with each in a 3D space. The dataset

<footnote n="2">² https://docs.scipy.org/doc/scipy</footnote>
<figure><img src="image_21.png" /><figcaption>**Fig. 19** One sample from each of the rehabilitation exercises of the Kimore dataset. Each sample showcases how different parts of the body change positions through time. The skeletons are color coded following the five different body parts: left and right legs (in **red**), left and right arms (in **green**) and spine (in **blue**).</figcaption></figure>

<table><caption>**Table 4** Accuracy of the baseline, 1-NN-DTW, three state-of-the-art deep learning models, FCN ResNet and InceptionTime compared to **ours** LITEMVTime on the Kimore human rehabilitation exercise. We present for each of the five exercises the accuracy of the models on the test unseen split.</caption><thead><tr><th>Kimore Exercise</th><th>1-NN-DTW</th><th>FCN</th><th>ResNet</th><th>InceptionTime</th><th>LITEMVTime</th></tr></thead><tbody><tr><td>Exercise 1</td><td>60.00</td><td>84.00</td><td>85.33</td><td>78.67</td><td><strong>86.67</strong></td></tr><tr><td>Exercise 2</td><td>46.67</td><td>72.00</td><td>69.33</td><td><u>78.67</u></td><td><strong>80.00</strong></td></tr><tr><td>Exercise 3</td><td>86.67</td><td><strong>92.00</strong></td><td>86.67</td><td><u>88.00</u></td><td>86.67</td></tr><tr><td>Exercise 4</td><td><strong>66.67</strong></td><td>65.33</td><td>60.00</td><td>57.33</td><td><strong>66.67</strong></td></tr><tr><td>Exercise 5</td><td>73.33</td><td><u>66.67</u></td><td>81.33</td><td><strong>84.00</strong></td><td>80.00</td></tr><tr><td>Average Accuracy</td><td>66.67</td><td>76</td><td>76.53</td><td><u>77.33</u></td><td><strong>80.00</strong></td></tr><tr><td>Average Rank</td><td>3.6</td><td>2.8</td><td>2.8</td><td><u>2.6</u></td><td><strong>1.8</strong></td></tr></tbody></table>

is made of 71 examples per exercise, where each sequence is a recording of one subject. For this reason, we can randomly split for each exercise the dataset into a 80% – 20% train test sets. In order to make sure samples of each class exist in the train test split, we make sure to stratify when randomly splitting the train/test sets with the labels (good/bad).

All samples are z-normalized in order to have a zero mean and unit standard variation. In Table 4, we present the accuracy performance for each of the five exercises using the three deep learning models from the literature: FCN, ResNet and InceptionTime, our proposed architecture LITEMVTime, and a baseline classifier 1-Nearest Neighbour-Dynamic Time Warping (1-NN-DTW) [41,3]. The experiments using 1-NN-DTW are conducted using *aeon* Python pacakge [39]. It can be concluded from the table that LITEMVTime is the best performing model for this task compared to the competitors following both the average performance and average rank over all exercises. This results show that a small deep learning model such as LITEMVTime can be used to classify if a patient is healthy or not given a recorded sequence of their exercise.

## 4.7 Explainability: Class Activation Map

Having a good performing deep learning model is important. However it is important to also be able to understand the decision making process of a deep learning model. This field has been
<figure><img src="image_22.png" /><figcaption>Fig. 20 The distribution of the scores given by experts to healthy (in blue) and unhealthy (in red) patients when performing each of the five different exercises. The threshold set to discretize these scores is chosen to be the middle point (line in green) posed at 50.</figcaption></figure>

significantly targeted in the last decade and in the domain of TSC for the last five years. Class Activation Map (CAM) is an explainability technique for deep CNNs, which helps interpreting the decision of CNNs as if they were black box models. It was first introduced in [63] for image datasets and got first adapted to time series data in [55]. It is important to note that the usage of CAM explainability necessities the usage of a global representative layer before the softmax classification layer. An example of such layers is the Global Average Pooling (GAP) used in FCN, ResNet, Inception, LITE and LITEMV. The outcome of a CAM in the case of TSC is a univariate time series. Each time stamp represents the importance of this time stamp in the input time series that lead to a specific decision making.

For the mathematical setup of CAM, we defined:

- the output of the last convolution layer as $O(t)$, which is a multivariate time series with $M$ variables, $M$ being the number of filters of this layer; In other words, $O_m(t)$ is the output univariate time series of filter $m$, where $m \in \{0, 1, \dots, M-1\}$;

- $\mathbf{w}^c = \{w_0^c, w_1^c, \dots, w_{M-1}^c\}$ as the weights vector connecting the GAP output to the neuron of the winning class (the class with the highest probability value)

The CAM output can be defined as follows:

$$CAM(t) = \sum_{m=0}^{M-1} w_m^c \mathbf{O}_m(t) \qquad (6)$$
<figure><img src="image_23.png" /><figcaption>**Fig. 21** Interpretability of the LITEMV model using the Class Activation Map (CAM) on the feature of the last DWSC layer. The colorbar values represent the normalized (between 0 and 1) scores of the CAM. Five samples from each of the five exercises are presented with the CAM scores on different time stamps. A higher CAM score indicates the importance of a time stamp for the decision making of LITEMV.</figcaption></figure>

This is followed by a min-max normalization on the CAM output. For two given time stamps, the one with the highest CAM score contributed more in the decision making of the black box deep learning model.

In this work, we use the CAM explainability technique to better understand the decision making of the LITEMV model on the human rehabilitation dataset Kimore. We use five different examples from each exercise, and produce the CAM output using a LITEMV model trained to solve the classification task of each exercise (see Figure 21). Given that in the case of human skeleton based data, the input is a multivariate time series, we suppose that the produced CAM values represent the temporal axis. In other words, for each time stamp, one CAM score represents the contribution of the current time pose (skeleton) to the classification.

To study more the changes in the CAM scores depending on the state of correctly classifying a sample, we present in Figure 22 two CAM explanations on two samples of the same exercise. The first sample is correctly classified as class 1 (*score* > 50) and the second is incorrectly classified as class 1 as it should be class 0 (*score* < 50). It can be seen that the first sample (top) has higher intensity in the CAM colors (so in the CAM scores), than the second sample (bottom). This indicates that the important time stamps for correctly classifying as class 1 will have lower scores, when the ground truth is actually class 0. This is due to the fact the CAM scores consider the weights of the winning class in the classification layer and not the weights of the ground truth.

## 4.8 Limitations of LITE and LITEMV

LITE and LITEMV have low complexity when compared to other architectures; so, one potential limitation can occur when using these methods for handling big data. For instance, LITE and LITEMV could fall short when a training set including millions of data is used. This shortcoming could be solved by increasing the number of filters operating in the DWSC layers: in fact, given the efficient way DWSC's apply convolutions, this would result in a slight increase in the cost.

A second limitation that affects all the architectures detailed in this work, is related to the length of the time series samples. This can be circumvented by increasing the CNN's Receptive Field (RF), which is the length of input visibility of the CNN at the last layer. Let us consider a
<figure><img src="image_24.png" /><figcaption>Fig. 22 Interpretability of the LITEMV model using the Class Activation Map (CAM) on the feature of the last DWSC layer. Two samples from the test split of the same exercise are presented, the first (top) having a ground truth of class 1, and the second (bottom) having a ground truth of class 0. LITEMV correctly classifies the first sample but incorrectly the second. It can be seen that the important time stamp in the case of the correctly classified sample has higher color intensity, so higher CAM score, compared to the same time stamp from the incorrectly classified sample.</figcaption></figure>

CNN with L convolution layers, of kernel size Kᵢ and dilation rate dᵢ, where i ∈ {0, 1, ..., L − 1}. The Receptive Field [34,37] of this model is computed as:

$$RF = 1 + \sum_{d_i * K_i}$$

This quantity varies from one CNN to another. For instance, in the case of FCN [55], the RF is 14 = 1 + 7 + 4 + 2. This RF is small compared to the length of the time series in the UCR archive. In the case of ResNet, the RF increases to 40, and to 235 for Inception. In the case of LITE and LITEMV, the RF is 114, which has been shown to be sufficient to achieve state-of-the-art performance on the UCR archive. However, this RF value needs to be increased if a dataset includes a significantly longer time series compared to this value. The RF value can be increased by either increasing the length of the filters, or by adding more layers to increase the model's depth. In usual CNN models, however, this is not an efficient approach given the fact it drastically increases the complexity of the network. This does not occur for LITE and LITEMV, making them suitable for such a solution.

## 5 Conclusions

In this paper, we addressed the Time Series Classification problem by reducing the number of parameters compared to existing deep learning approaches for Time Series Classification, while preserving performance of InceptionTime. We presented a new architecture for Time Series Classification, LITE, and evaluated its performance on the UCR archive. LITE has only 2.34% of InceptionTime's number of parameters. This model is faster than the state-of-the-art in training and inference time. It consumes as well less CO₂ and power, which is a topic we believe to be very important nowadays. Results have illustrated that the usage of LITE allows us to achieve state-of-the-art results on the UCR archive. Furthermore, the presented ablation study demonstrated the importance of the techniques used in LITE. Furthermore, we also adapted LITE to handle multivariate time series data, LITEMV. Experiments on the UEA multivariate TSC archive showed promising performance on some datasets compared to the state-of-the-art. Finally, we showcased
the utility of LITEMV in a real application, where human rehabilitation exercises are evaluated. In this context, we showed that LITEMVTime outperforms other models on the Kimore dataset. We believe this work can represent a starting point for optimizing deep learning architectures in the time series domain. We believe that this study can address clustering, representation learning and generative models as well. In future work, we aim to tackle these others domains given the impressive performance of LITE compared to ResNet and InceptionTime.

## Acknowledgments

This work was supported by the ANR DELEGATION project (grant ANR-21-CE23-0014) of the French Agence Nationale de la Recherche. The authors would like to acknowledge the High Performance Computing Center of the University of Strasbourg for supporting this work by providing scientific support and access to computing resources. Part of the computing resources were funded by the Equipex Equip@Meso project (Programme Investissements d'Avenir) and the CPER Alsacalcul/Big Data. The authors would also like to thank the creators and providers of the UCR, UEA Archives and the Kimore dataset.

## Declarations

- **Funding** This work was supported by the ANR DELEGATION project (grant ANR-21-CE23-0014) of the French Agence Nationale de la Recherche.

- **Conflict of interest** The authors certify that they have no conflict of interest in the subject matter or materials discussed in this manuscript.

- **Availability of data and materials** All of the datasets used in this work are publicly available.

- **Code availability** The source code is available on this github repository: https://github.com/MSD-IRIMAS/LITE

- **Authors' contributions** Conceptualization: AIF; Methodology: AIF, MD, SB, JW and GF; Experiments: AIF, MD; Validation: MD, SB, JW and GF; Writing—original draft: AIF; Writing—review and editing: AIF, MD, SB, JW and GF; Funding acquisition: MD; all authors have read and agreed to the published version of the manuscript.

## References

1. Ay, E., Devanne, M., Weber, J., Forestier, G.: A study of knowledge distillation in fully convolutional network for time series classification. In: 2022 International Joint Conference on Neural Networks (IJCNN). pp. 1–8. IEEE (2022)

2. Bagnall, A., Dau, H.A., Lines, J., Flynn, M., Large, J., Bostrom, A., Southam, P., Keogh, E.: The uea multivariate time series classification archive, 2018. arXiv preprint arXiv:1811.00075 (2018)

3. Bagnall, A., Lines, J., Bostrom, A., Large, J., Keogh, E.: The great time series classification bake off: a review and experimental evaluation of recent algorithmic advances. Data mining and knowledge discovery **31**(3), 606–660 (2017)

4. Bai, S., Kolter, J.Z., Koltun, V.: An empirical evaluation of generic convolutional and recurrent networks for sequence modeling. arXiv preprint arXiv:1803.01271 (2018)
5. Benavoli, A., Corani, G., Mangili, F.: Should we really use post-hoc tests based on mean-ranks? The Journal of Machine Learning Research **17**(1), 152–161 (2016)

6. Brown, T., Mann, B., Ryder, N., Subbiah, M., Kaplan, J.D., Dhariwal, P., Neelakantan, A., Shyam, P., Sastry, G., Askell, A., et al.: Language models are few-shot learners. Advances in neural information processing systems **33**, 1877–1901 (2020)

7. Capecci, M., Ceravolo, M.G., Ferracuti, F., Iarlori, S., Monteriu, A., Romeo, L., Verdini, F.: The ki- more dataset: Kinematic assessment of movement and clinical scores for remote monitoring of physical rehabilitation. IEEE Transactions on Neural Systems and Rehabilitation Engineering **27**(7), 1436–1448 (2019)

8. Cui, Z., Chen, W., Chen, Y.: Multi-scale convolutional neural networks for time series classification. arXiv preprint arXiv:1603.06995 (2016)

9. Dau, H.A., Bagnall, A., Kamgar, K., Yeh, C.C.M., Zhu, Y., Gharghabi, S., Ratanamahatana, C.A., Keogh, E.: The ucr time series archive. IEEE/CAA Journal of Automatica Sinica **6**(6), 1293–1305 (2019)

10. Dempster, A., Petitjean, F., Webb, G.I.: Rocket: exceptionally fast and accurate time series classification using random convolutional kernels. Data Mining and Knowledge Discovery **34**(5), 1454–1495 (2020)

11. Dempster, A., Schmidt, D.F., Webb, G.I.: Minirocket: A very fast (almost) deterministic transform for time series classification. In: Proceedings of the 27th ACM SIGKDD conference on knowledge discovery & data mining. pp. 248–257 (2021)

12. Demšar, J.: Statistical comparisons of classifiers over multiple data sets. The Journal of Machine Learning Research **7**, 1–30 (2006)

13. Deng, J., Dong, W., Socher, R., Li, L.J., Li, K., Fei-Fei, L.: Imagenet: A large-scale hierarchical image database. In: 2009 IEEE conference on computer vision and pattern recognition. pp. 248–255. Ieee (2009)

14. Devanne, M., Wannous, H., Berretti, S., Pala, P., Daoudi, M., Del Bimbo, A.: 3-d human action recogni- tion by shape analysis of motion trajectories on riemannian manifold. IEEE transactions on cybernetics **45**(7), 1340–1352 (2014)

15. Fawaz, H.I., Forestier, G., Weber, J., Idoumghar, L., Muller, P.A.: Transfer learning for time series classification. In: 2018 IEEE international conference on big data (Big Data). pp. 1367–1376. IEEE (2018)

16. Fawaz, H.I., Forestier, G., Weber, J., Idoumghar, L., Muller, P.A.: Adversarial attacks on deep neu- ral networks for time series classification. In: 2019 International Joint Conference on Neural Networks (IJCNN). pp. 1–8. IEEE (2019)

17. Fawaz, H.I., Forestier, G., Weber, J., Idoumghar, L., Muller, P.A.: Deep neural network ensembles for time series classification. In: 2019 International Joint Conference on Neural Networks (IJCNN). pp. 1–6. IEEE (2019)

18. Forestier, G., Lalys, F., Riffaud, L., Trelhu, B., Jannin, P.: Classification of surgical processes using dynamic time warping. Journal of biomedical informatics **45**(2), 255–264 (2012)

19. Foumani, N.M., Tan, C.W., Webb, G.I., Salehi, M.: Improving position encoding of transformers for multivariate time series classification. Data mining and knowledge discovery (2023)

20. Foumani, S.N.M., Tan, C.W., Salehi, M.: Disjoint-cnn for multivariate time series classification. In: 2021 International Conference on Data Mining Workshops (ICDMW). pp. 760–769. IEEE (2021)

21. He, K., Zhang, X., Ren, S., Sun, J.: Deep residual learning for image recognition. In: Proceedings of the IEEE conference on computer vision and pattern recognition. pp. 770–778 (2016)

22. Hinton, G., Vinyals, O., Dean, J., et al.: Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531 **2**(7) (2015)
23. Howard, A.G., Zhu, M., Chen, B., Kalenichenko, D., Wang, W., Weyand, T., Andreetto, M., Adam, H.: Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861 (2017)

24. Ismail-Fawaz, A., Dempster, A., Tan, C.W., Herrmann, M., Miller, L., Schmidt, D.F., Berretti, S., Weber, J., Devanne, M., Forestier, G., et al.: An approach to multiple comparison benchmark evaluations that is stable under manipulation of the comparate set. arXiv preprint arXiv:2305.11921 (2023)

25. Ismail-Fawaz, A., Devanne, M., Berretti, S., Weber, J., Forestier, G.: Lite: Light inception with boosting techniques for time series classification. In: 2023 IEEE 10th International Conference on Data Science and Advanced Analytics (DSAA). pp. 1–10. IEEE (2023)

26. Ismail-Fawaz, A., Devanne, M., Berretti, S., Weber, J., Forestier, G.: Finding foundation models for time series classification with a pretext task. In: Pacific-Asia Conference on Knowledge Discovery and Data Mining. pp. 123–135. Springer (2024)

27. Ismail-Fawaz, A., Devanne, M., Weber, J., Forestier, G.: Deep learning for time series classification using new hand-crafted convolution filters. In: 2022 IEEE International Conference on Big Data (IEEE BigData 2022). pp. 1–8. IEEE (2022)

28. Ismail-Fawaz, A., Devanne, M., Weber, J., Forestier, G.: Enhancing time series classification with self-supervised learning. In: 15th International Conference on Agents and Artificial Intelligence: ICAART 2023. INSTICC, SciTePress (2023)

29. Ismail Fawaz, H., Forestier, G., Weber, J., Idoumghar, L., Muller, P.A.: Evaluating surgical skills from kinematic data using convolutional neural networks. In: International Conference on Medical Image Computing and Computer-Assisted Intervention. pp. 214–221. Springer (2018)

30. Ismail Fawaz, H., Forestier, G., Weber, J., Idoumghar, L., Muller, P.A.: Deep learning for time series classification: a review. Data mining and knowledge discovery **33**(4), 917–963 (2019)

31. Ismail Fawaz, H., Lucas, B., Forestier, G., Pelletier, C., Schmidt, D.F., Weber, J., Webb, G.I., Idoumghar, L., Muller, P.A., Petitjean, F.: Inceptiontime: Finding alexnet for time series classification. Data Mining and Knowledge Discovery **34**(6), 1936–1962 (2020)

32. Ji, S., Xu, W., Yang, M., Yu, K.: 3d convolutional neural networks for human action recognition. IEEE transactions on pattern analysis and machine intelligence **35**(1), 221–231 (2012)

33. Lafabregue, B., Weber, J., Gançarski, P., Forestier, G.: End-to-end deep representation learning for time series clustering: a comparative study. Data Mining and Knowledge Discovery **36**(1), 29–81 (2022)

34. Liu, Y., Yu, J., Han, Y.: Understanding the effective receptive field in semantic image segmentation. Multimedia Tools and Applications **77**, 22159–22171 (2018)

35. Lucas, B., Shifaz, A., Pelletier, C., O’Neill, L., Zaidi, N., Goethals, B., Petitjean, F., Webb, G.I.: Proximity forest: an effective and scalable distance-based classifier for time series. Data Mining and Knowledge Discovery **33**(3), 607–635 (2019)

36. Lun, R., Zhao, W.: A survey of applications and human motion recognition with microsoft kinect. International Journal of Pattern Recognition and Artificial Intelligence **29**(05), 1555008 (2015)

37. Luo, W., Li, Y., Urtasun, R., Zemel, R.: Understanding the effective receptive field in deep convolutional neural networks. Advances in neural information processing systems **29** (2016)

38. Madrid, F., Singh, S., Chesnais, Q., Mauck, K., Keogh, E.: Matrix profile xvi: efficient and effective labeling of massive time series archives. In: 2019 IEEE International Conference on Data Science and Advanced Analytics (DSAA). pp. 463–472. IEEE (2019)

39. Middlehurst, M., Ismail-Fawaz, A., Guillaume, A., Holder, C., Rubio, D.G., Bulatova, G., Tsaprounis, L., Mentel, L., Walter, M., Schäfer, P., et al.: aeon: a python toolkit for learning from time series. arXiv preprint arXiv:2406.14231 (2024)
40. Middlehurst, M., Large, J., Flynn, M., Lines, J., Bostrom, A., Bagnall, A.: Hive-cote 2.0: a new meta ensemble for time series classification. Machine Learning **110**(11-12), 3211–3243 (2021)

41. Middlehurst, M., Schäfer, P., Bagnall, A.: Bake off redux: a review and experimental evaluation of recent time series classification algorithms. arXiv preprint arXiv:2304.13029 (2023)

42. Pialla, G., Devanne, M., Weber, J., Idoumghar, L., Forestier, G.: Data augmentation for time series classification with deep learning models. In: Advanced Analytics and Learning on Temporal Data (AALTD) (2022)

43. Pialla, G., Fawaz, H.I., Devanne, M., Weber, J., Idoumghar, L., Muller, P.A., Bergmeir, C., Schmidt, D., Webb, G., Forestier, G.: Smooth perturbations for time series adversarial attacks. In: Advances in Knowledge Discovery and Data Mining: 26th Pacific-Asia Conference, PAKDD 2022, Chengdu, China, May 16–19, 2022, Proceedings, Part I. pp. 485–496. Springer (2022)

44. Pinto, J.P., Pimenta, A., Novais, P.: Deep learning and multivariate time series for cheat detection in video games. Machine Learning **110**(11-12), 3037–3057 (2021)

45. Raschka, S., Patterson, J., Nolet, C.: Machine learning in python: Main developments and technology trends in data science, machine learning, and artificial intelligence. arXiv preprint arXiv:2002.04803 (2020)

46. Risso, M., Burrello, A., Conti, F., Lamberti, L., Chen, Y., Benini, L., Macii, E., Poncino, M., Pagliari, D.J.: Lightweight neural architecture search for temporal convolutional networks at the edge. IEEE Transactions on Computers **72**(3), 744–758 (2022)

47. Ruiz, A.P., Flynn, M., Large, J., Middlehurst, M., Bagnall, A.: The great multivariate time series classification bake off: a review and experimental evaluation of recent algorithmic advances. Data Mining and Knowledge Discovery **35**(2), 401–449 (2021)

48. Sandler, M., Howard, A., Zhu, M., Zhmoginov, A., Chen, L.C.: Mobilenetv2: Inverted residuals and linear bottlenecks. In: Proceedings of the IEEE conference on computer vision and pattern recognition. pp. 4510–4520 (2018)

49. Schick, T., Schütze, H.: It’s not just size that matters: Small language models are also few-shot learners. arXiv preprint arXiv:2009.07118 (2020)

50. Tan, C.W., Dempster, A., Bergmeir, C., Webb, G.I.: Multirocket: Multiple pooling operators and transformations for fast and effective time series classification. Data Mining and Knowledge Discovery pp. 1–24 (2022)

51. Tanisaro, P., Heidemann, G.: Time series classification using time warping invariant echo state networks. In: 2016 15th IEEE International Conference on Machine Learning and Applications (ICMLA). pp. 831–836. IEEE (2016)

52. Tao, L., Elhamifar, E., Khudanpur, S., Hager, G.D., Vidal, R.: Sparse hidden markov models for surgical gesture classification and skill evaluation. In: International conference on information processing in computer-assisted interventions. pp. 167–177. Springer (2012)

53. Terefe, T., Devanne, M., Weber, J., Hailemariam, D., Forestier, G.: Time series averaging using multitasking autoencoder. In: 2020 IEEE 32nd International Conference on Tools with Artificial Intelligence (ICTAI). pp. 1065–1072. IEEE (2020)

54. Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A.N., Kaiser, Ł., Polosukhin, I.: Attention is all you need. Advances in neural information processing systems **30** (2017)

55. Wang, Z., Yan, W., Oates, T.: Time series classification from scratch with deep neural networks: A strong baseline. In: 2017 International joint conference on neural networks (IJCNN). pp. 1578–1585. IEEE (2017)

56. Wickstrøm, K., Kampffmeyer, M., Mikalsen, K.Ø., Jenssen, R.: Mixing up contrastive learning: Self-supervised representation learning for time series. Pattern Recognition Letters **155**, 54–61 (2022)
57. Wilcoxon, F.: Individual comparisons by ranking methods. In: Breakthroughs in statistics, pp. 196–202. Springer (1992)

58. Younis, R., Zerr, S., Ahmadi, Z.: Multivariate time series analysis: An interpretable cnn-based model. In: 2022 IEEE 9th International Conference on Data Science and Advanced Analytics (DSAA). pp. 1–10. IEEE (2022)

59. Zanghieri, M., Benatti, S., Burrello, A., Kartsch, V., Conti, F., Benini, L.: Robust real-time embedded emg recognition framework using temporal convolutional networks on a multicore iot processor. IEEE transactions on biomedical circuits and systems 14(2), 244–256 (2019)

60. Zerveas, G., Jayaraman, S., Patel, D., Bhamidipaty, A., Eickhoff, C.: Representation learning of multivariate time series using a transformer framework. In: ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (2021)

61. Zhao, J., Itti, L.: shapedtw: Shape dynamic time warping. Pattern Recognition **74**, 171–184 (2018)

62. Zheng, Y., Liu, Q., Chen, E., Ge, Y., Zhao, J.L.: Exploiting multi-channels deep convolutional neural networks for multivariate time series classification. Frontiers of Computer Science **10**(1), 96–112 (2016)

63. Zhou, B., Khosla, A., Lapedriza, A., Oliva, A., Torralba, A.: Learning deep features for discriminative localization. In: Proceedings of the IEEE conference on computer vision and pattern recognition. pp. 2921–2929 (2016)