Time-series clustering-as-a-service is an innovative and promising research area. Its main goal is to design Cloud-based platforms and services able to provide eficient and efective time-series clustering directly to final users. This paper introduces T4C, an open-source Python-based framework for timeseries clustering-as-a-service. T4C integrates some of the most used time-series clustering models and techniques, and it is able to generate on-the-fly websites where users can explore the result of the clustering procedure on their previously uploaded time-series.
repository1, has been applied with promising results to the COVID-19 pandemic spread. The paper is organized as follows. Section 2 presents the related literature, while Section 3 presents the background on the topic. The T4C framework is presented in Section 4, with experiments on the COVID-19 case study presented in Section 5. Conclusions are finally drawn in Section 6.
This Section presents the state-of-the-art in the field of time-series clustering, as well as some
insights into the more specific topic of time-series solutions as-a-service. The literature on
time-series clustering is very rich, considering the high interest of both the scientific and
industrial world on the topic. The works [
Time-series clustering is an unsupervised data mining technique whose goal is to organize time-series into groups based on their similarity. The result of the clustering should maximize data similarity within clusters and minimize it across clusters [12].
In general, the methods for time-series clustering may be grouped into three categories according to the way in which they consider the input data. The first category, called shape or observation based, deals directly with the raw time-series, either in the frequency, time, or wavelet domain. The second approach, called feature based, deals with numerical features extracted from the time-series. Such features may include the mean, variance, etc. Lastly, the third approach is called model-based. In this case models are trained on the time-series and are then used to find and cluster the incoming time-series.
Two aspects are fundamental for an efective time-series clustering, general for all the presented approaches: the representation method, and the similarity measures. Representation methods are used to reduce the dimensionality of input time-series. This is highly relevant in a 1https://github.com/uGR17/TIMEX_CLUSTERING scenario in which the time-series to cluster present important dimensionality, hence negatively impacting the temporal and memory complexity of the clustering models. The most common techniques work in the time or frequency domain (e.g., Discrete Fourier Transformation (DFT), Single Value Decomposition (SVD), etc.).
A distance measure gives a numerical and quantifiable indicator on the similarity (in shape, behavior, etc.) of two time-series; notable examples include the Euclidean distance (ED), Dynamic Time Warping (DTW), distance based on Longest Common Subsequence (LCSS), etc. Some distance measures are specific to a certain representation method, while others are independent from that aspect. A correct choice of a distance measure is critical, because it should take into account the various aspects of a time-series (i.e., presence of noise, scaling, presence of drift, etc.).
The presented T4C framework includes all these aspects in a single framework; it is detailed in the next Section.
This Section introduces the T4C framework presented in this study, explaining all its blocks. T4C (TIMEX For Clustering) is a Python framework for automatic time-series clustering as-a-service. It aims to give users an end-to-end pipeline, where only the input time-series are requested, with the results of the clustering procedure directly accessible by users. It is inspired by TIMEX [13], a framework for time-series forecasting as-a-service. T4C is meant to be used in two ways: 1. to create web dashboards which present the result of the clustering in a user-friendly way, on a given dataset (like in the case presented in Section 5); 2. to build a website which allows users to upload their time-series, an optional set of parameters to tune the clustering, and to get the results of the clustering directly online. The framework only needs the input time-series to cluster. If not given, the configuration parameters to tune the T4C pipeline are set on default values.
The pipeline of T4C is shown in Fig. 1, while details on all the intermediate blocks are given as follows. Such pipeline comprises the following six steps: data ingestion, data pre-processing, data description, data clustering and service delivery.
The data ingestion phase is the entry point of the T4C framework. The goal of the data ingestion step is to obtain a Python representation of the input dataset, contained in a CSV or JSON file. In more details, a dataset is composed of N time-series, each one composed of data points. T4C is able to recover a CSV or JSON file if its URL is specified, in case the dataset is available online. Once the file is downloaded or obtained, T4C will obtain a Pandas [ 14] DataFrame out of it, with a time index and columns, being the number of time-series present in the dataset.
Moreover, in this phase, the user may also specify a JSON configuration file. This file can contain parameters used to modify the standard behavior of the clustering pipeline (e.g., consider only a subset of models, etc.).
Data ingestion Pandas ingestion Dates parsing
Missing values interpolation Frequency inference
Data pre-processing
Data description
Data clustering
Feature transformation selection
Plots
Model
Distance selection measurement and validation
Evaluation criteria
Results presentation
REST, web-site JSON / website result
Resualltls for Best approaches clustering
Clusters found
Then, the data pre-processing step is activated. Its main goal is to fix eventual problems in the input dataset, by means of some sub-steps.
Often, datasets contain missing values, for various reasons. However, clustering algorithms generally require that input time-series have the same number of data points and that no value is missing. A solution for this problem is to use data interpolation functions, or even to re-sample the input time-series. T4C, in practice, relies on Pandas for the standardly used data interpolation mechanisms (e.g., linear interpolation). Moreover, the estimated periodicity of the time-series can be found by looking at the minimum sampling period in the whole dataset. If the time-series have an irregular frequency, this can be fixed by enforcing the estimated frequency and by interpolating the (eventually) missing values.
Once missing data have been handled, the data streams are modified through data transformation techniques to have a more canonical representation of the time-series. In particular, three diferent data transformation techniques are available in T4C. The first is a scaler transformation which modifies the time-series in order to have a mean of 0 and a variance of 1. The other two transformations are considered to make the time-series stationary. A time-series is stationary if its statistical properties do not vary over time [15]. Stationarity can be of benefit for specific families of clustering models. For this purpose and to manage exponentially-increasing time-series, T4C relies on a modified logarithmic transformation:
_ () = () · (|| + 1).
The Data description phase is composed of two steps. The first is the automatic creation of plots using the Python library Plotly. These are the plots which will be provided to users through the web-console or the generated web-site. Then, the distance measurement part includes the
Gaussian mixture model
computation of various distance metrics between the time-series composing the dataset. The distance metrics managed by T4C are shown in the following.
T4C can take advantage of three clustering models, taking from state-of-the-art literature on time-series clustering. Namely, they are: K-Means (for the Observation and Feature based approaches), and Gaussian Mixture model (for the model based approach). One of the key points of the software development of T4C is to have a software architecture which allows easy additions to the library of available models. It is again stressed that if the user does not specify which models to use, T4C will try to use all the available models in order to find the one which performs the best.
T4C evaluates the performance of the clustering, for each model, according to three diferent internal index measures. The three indices available in T4C are: Silhouette index, CalinskiHarabasz, and Davies-Bouldin. Given that, unfortunately, there is not a universally accepted measure to assess the quality of a time-series clustering, the user may specify which of these indices consider to suggest the best available clustering among the ones obtained.
The last part of the pipeline of T4C aims at providing the results of the clustering procedure to users. For this goal, two diferent mechanisms are available: the first is a REST endpoint, and the second is a website automatically generated by the framework.
The first option for users is to use the T4C REST service, built with Python Flask. The user can use any client able to perform REST requests both to start the entire pipeline (in this case the POST request should contain the dataset/configuration JSON), or to query the service when the results are available. The final results are provided in the form of a ZIP file containing the plots generated in the previous steps, in PNG format, and a JSON file which lists the found clusters along with the cluster distributions.
The second option for users is to directly access, through a web browser, a website generated on-the-fly by T4C. The website, built with the Dash Python library, allows users to see the aforementioned plots and results of the clustering procedure. In this case, moreover, the various graphical aids will be interactive thanks to the use of Python Plotly. There are two ways in which the website can be generated. The former is useful when a user needs to set up a dashboard for other users, about the clustering of a specific dataset. For instance, consider the case presented in the experimental section (Section 5), where a data analyst wants to give policymakers access to some data useful to control a certain phenomenon. In this case the clustering pipeline proceeds ofline, when the data analyst starts it, and the results are publicly available through the website. This particular choice has been made for the COVID-19 experimental campaign presented in Section 5. Instead, in the latter scenario, T4C is deployed completely in an as-a-service manner. This means that all (or a subset of) users can access the website and provide a dataset by themselves. In this case, the pipeline starts at that moment, and the webpage—diferent for each user—will be provided to them at the end of the pipeline.
In this Section experiments on a representative case study for the T4C are presented. We highlight that the webpage generated by T4C, which corresponds to the final part of the time-series clustering pipeline, is publicly accessible on the web 2.
The framework has been applied to the COVID-19 pandemic spread. In this context, using clustering in a fully automatic way can provide useful information to decision makers. The used dataset is composed of the Daily cases of COVID-19 time-series in 181 countries around the world, starting from February 24, 2020, to February 20, 2022 [16]. The goal of this clustering task is to group countries which present a similar evolution of their COVID-19 cases. An important comment to make is that putting two countries in the same group can be extremely valuable for decision makers, because it can help to understand which anti-COVID measures were efective and which were not. T4C ingested the time-series given as input, producing the plot depicted in Fig 2. This plot is automatically created by the framework, and is part of the service provided to final users.
T4C has been applied on the COVID-19 dataset using standard parameters. In detail, it means that the three clustering approaches available in the framework are tried (i.e., observation based, feature based, and model based). This allows the user to have a fair comparison between diferent approaches. Two clustering algorithms are applied, namely K-Means (for the observation and feature based approaches) and Gaussian Mixture model (for the model based approach). In particular, the feature based approach will leverage DWT using Haar wavelet. Lastly, 3 to 6 clusters will be evaluated. It is stressed that, looking at the metrics, it will be possible to automatically understand the number of clusters which produces the most efective clustering. For what concerns the distance metrics, the Euclidean and DTW are used, while soft-DTW is not used due to the large dimensionality of the dataset. Diferent data pre-processing transformations are present.
As shown in Table 2, the framework produced results for all the considered clustering approaches, models, transformations, etc. Notably, in all the cases, T4C concluded that 3 is the number of clusters which ofers the most efective clustering result. Even though the highest Silhouette score (i.e., 0.910) is reached by the Feature based clustering with K-Means model, no data transformation and Euclidean distance metric, a closer look at the produced clusters highlighted something diferent.
Indeed, this clustering approach just divided USA and India in two separate clusters, to group all the other countries in Cluster 2. This is mainly given to the fact that, by not applying any 3 3 3 3 3 3 3 3 3 3 0.908 0.870 0.295 0.332 0.910 0.862 0.303 0.369 0.886 0.279 pre-transformation on the data, it is not possible to consider similarities between countries which—considering their population—have obviously diferent magnitudes of Daily cases of COVID-19.
Interestingly, the Feature based approach, with K-Means model, a log-modified pretransformation on the input data, and with DTW distance metric, produced more convincing results. In this case, even though the Silhouette score is 0.369, the clusters appear much more compact.
In Table 3 the clusters which obtained the best results are shown. In Cluster 1, T4C grouped countries that faced diferent infection peaks during the period considered, namely Italy, France, Spain, USA, etc. The pandemic in these countries has been characterized by recurrent peaks of cases. Interestingly, the peaks got worse and worse; this is explained by the fact that also the number of tests incremented continuously during those months.
In Cluster 2 there are countries which did not sufer from those peaks in the Daily cases time-series. It may matter either that they better controlled the pandemic, or that they did not make enough tests—letting many COVID-19 cases go undetected. Establishing this is outside of the scope of this paper.
In Cluster 3, lastly, there are countries which sufered from peaks in the Daily cases timeseries as well. The diference w.r.t. Cluster 1 is that the time-series did not show the exponential growth which happened in countries in Cluster 1.
A final graphical representation of the clusters, automatically generated by T4C, is shown in Fig. 3.
T4C is the second of a series of tools (after TIMEX) whose goal is to provide end-to-end pipelines for time-series modeling, directly usable by end users. In particular, T4C provides an entire time-series clustering pipeline by means of a Python package, released as an open-source repository to the scientific community. Future works will consider the addition of diferent clustering models and distance metrics, while—at a higher level—future works will also include similar software frameworks for other time-series tasks.
The authors would like to thank Dr. Uriel Guadarrama Ramirez for his valuable help. M. Rußwurm, K. Kolar, E. Woods, Tslearn, a machine learning toolkit for time series data, Journal of Machine Learning Research 21 (2020) 1–6. URL: http://jmlr.org/papers/v21/ 20-091.html. [12] A. Yeshchenko, C. D. Ciccio, J. Mendling, A. Polyvyanyy, Comprehensive process drift detection with visual analytics, in: International Conference on Conceptual Modeling, Springer, 2019, pp. 119–135. [13] A. Falcetta, M. Roveri, Timex: an automatic framework for time-series forecasting-as-aservice, in: Proceedings of the 28th ACM SIGKDD Conference on Knowledge Discovery & Data Mining, 2022. [14] T. pandas development team, pandas-dev/pandas: Pandas, 2020. URL: https://doi.org/10.
5281/zenodo.3509134. doi:10.5281/zenodo.3509134. [15] A. Nielsen, Practical Time Series Analysis: Prediction with Statistics and Machine Learning, O’Reilly Media, Incorporated, 2019. URL: https://books.google.com.mx/books?id= uq0avgEACAAJ. [16] H. Ritchie, E. Mathieu, L. Rodés-Guirao, C. Appel, C. Giattino, E. Ortiz-Ospina, J. Hasell, B. Macdonald, D. Beltekian, M. Roser, Coronavirus pandemic (covid-19), Our World in Data (2020). Https://ourworldindata.org/coronavirus.